How Zernio scaled to 6M daily posts on a 7-person team with Tinybird

About the company

Zernio is a unified API for social media and messaging. Instead of building and maintaining separate integrations for Instagram, TikTok, LinkedIn, WhatsApp, Telegram, and a dozen other platforms, developers connect to Zernio once and get publishing, scheduling, comments, DMs, analytics, and ads across 15 platforms.

In just eleven months Zernio hit $2M ARR, 2,000+ paying users, and 150,000+ connected social accounts. The company is bootstrapped, profitable, based in Spain, and run by a seven-person team.

Problem

Zernio started with a simple stack: Next.js on Vercel and a single MongoDB instance handling logs, analytics, and business logic. It worked until the team shipped user-facing analytics for posts published through Zernio.

At Zernio's scale, MongoDB became a bottleneck. Analytics pages loaded slowly. Queries timed out. The ingestion load started dragging down the entire database, not just the analytics features. The team was spending engineering time debugging slow Mongo queries instead of shipping.

Why Tinybird

Tinybird fit how Zernio already worked. The team is TypeScript end-to-end, so the TypeScript SDK let them define data sources, Pipes, and endpoints as code. Branches gave them safe staging environments for data changes. CI/CD deployments let them ship analytics infrastructure through the same workflow they used for the rest of the product.

The migration from MongoDB to Tinybird took less than a week.

Results

• 700,000 API requests per day. Zernio serves high-volume analytics traffic through Tinybird endpoints.
• 16.7 million rows ingested daily. Roughly 8 GB of new analytics data lands in Tinybird every day.
• 250ms p95 endpoint latency. User-facing analytics stays fast even as connected accounts and synchronized posts grow.
• New data features ship in hours. Features that used to take weeks of MongoDB work now move through Zernio's normal development workflow.

MongoDB hit a wall fast

Zernio's early stack was intentionally simple: Next.js on Vercel and a single MongoDB instance handling everything. Logs. Analytics. Business logic. For the first few months, it was fine.

Then Zernio shipped user-facing analytics for posts published through the platform, and the cracks appeared immediately. The volume of data made MongoDB's limitations obvious. Timeouts became constant. Analytics pages loaded slowly. The ingestion load started affecting the entire database.

For a seven-person team, that infrastructure tax was too expensive.

Zernio was synchronizing more than 6 million posts and 1 million ads every day. The team needed analytics infrastructure that could handle that data volume without slowing down the product database or forcing the team into weeks of database work every time they wanted to ship a new feature.

Why Zernio chose Tinybird

Zernio did not run a long evaluation. The team had already seen positive signals across the ecosystem. Open-source projects they admired, including Dub.co, were using Tinybird. Vercel was building on it. Tinybird's videos, blog posts, and docs gave them confidence that they could ramp up quickly.

Three things made the decision straightforward: The TypeScript SDK, Tinybird Branches to have safe staging environments, and the way of integrating the data layer with git as they do with the code.

The TypeScript SDK fit their workflow

Zernio's stack is TypeScript end-to-end. Tinybird's TypeScript SDK meant the team could define data sources, Pipes, and endpoints as code instead of clicking through a separate UI.

Tinybird felt like part of their codebase, not a separate system they had to manage on the side.

Branches gave them safe staging environments

Before touching production, Zernio can spin up a Tinybird branch with data:

npx tinybird build --last-partition

Or create a clean branch:

npx tinybird build

They develop locally with npx tinybird dev, test changes, and preview exactly what will change before deploying:

npx tinybird deploy --dry-run

Production deployments run automatically through CI/CD with:

npx tinybird deploy

The whole flow lives inside their existing development process: branch, develop, preview, deploy.

Config-as-code kept the data layer organized

Materialized views, data sources, and endpoints are files in a folder. Drop a file in, and it registers automatically.

// tinybird.config.mjs
/** @type {import('@tinybirdco/sdk').TinybirdConfig} */
export default {
  include: [
    "libs/tinybird/datasources/**/*.ts",
    "libs/tinybird/endpoints/**/*.ts",
    "libs/tinybird/materializations/**/*.ts",
    "libs/tinybird/client.ts",
  ],
  token: process.env.TINYBIRD_TOKEN,
  baseUrl: process.env.TINYBIRD_URL,
  devMode: "branch"
};

For Zernio, that mattered. They did not want an analytics stack that required a separate operating model. They wanted a data layer they could review, test, and deploy like product code.

The migration took less than a week

Once Zernio decided to move, the migration was fast. Pau, one of the engineers, handled it end-to-end in less than a week.

The biggest surprise was how little ceremony the team needed.

For a team already deep in integrations across 15 social and messaging platforms, adding another complex system would have been costly. Tinybird did not feel like one.

Analytics infrastructure that stays out of the way

Today, Zernio's Tinybird-powered analytics infrastructure handles serious volume without becoming a dedicated workstream for the team.

Zernio customers now get access to webhook logs, post and message logs, ads analytics, publishing analytics, inbox analytics, and workflow run logs. These features work for customers with thousands of connected accounts and high-volume social media operations.

Before Tinybird, shipping that kind of feature meant worrying about MongoDB query performance, ingestion load, and whether the database would hold up. Now Zernio can build the feature and let Tinybird handle the analytics workload.

Small team, big infrastructure

What makes Zernio's story stand out is not just the volume. It is the team behind it.

Seven people. Less than a year old. Bootstrapped. Profitable. Moving enough data to compete with companies many times their size.

Tinybird gave Zernio the foundation to keep shipping data-intensive features without building a dedicated data infrastructure team. The TypeScript SDK fits their codebase. Branches make changes safe. CI/CD deployments make the data layer part of normal product development.

For a bootstrapped team in Spain building serious infrastructure profitably, that is exactly the kind of foundation they need.