Layerbase vs Tinybird: real-time analytics without the usage meter

If you are evaluating Tinybird, you are almost certainly building something that needs fast analytical queries over a lot of rows: product analytics, real-time dashboards, usage metering, leaderboards, or an API that has to aggregate millions of events and answer in milliseconds. That is ClickHouse territory, and Tinybird is one of the best-known ways to get ClickHouse without running it yourself.

So where does Layerbase fit? Both can serve the same workload, but they are not the same kind of product, and the answer to "which should I use" depends less on features than on how you want to be billed and how much of the pipeline you want owned for you.

They are not the same shape

This is the part most comparison posts skip, so let us be direct about it.

Tinybird is an opinionated real-time analytics platform built on ClickHouse. You do not get a raw ClickHouse endpoint to point your BI tool at. You ingest into Data Sources, transform with chained SQL "Pipes", and publish those pipes as token-authenticated REST API Endpoints. The current iteration, Tinybird Forward, keeps that model and adds typed SDKs plus a tb CLI with a local dev container. The value is the whole managed pipeline: ingestion connectors, the query layer, and an instant API in front of it, with observability on top.

Layerbase gives you managed ClickHouse itself. You get a real ClickHouse instance with a native wire-protocol connection string and a TLS endpoint. You connect the ClickHouse client, clickhouse-connect, your BI tool, or anything that speaks the protocol. There is no Pipes abstraction and no auto-generated API layer. If you want an HTTP API in front of your queries, you build it, the same way you would in front of any database.

That difference is the whole decision. Tinybird sells you a pipeline. Layerbase sells you the engine and gets out of the way.

The pricing wedge

Tinybird's pricing is usage-based, and the meter these days is compute: your queries and ingestion burn vCPU time, bursts beyond your plan's base vCPUs are billed per vCPU-second, and storage is billed per GB on top (current pricing). The free tier is real and needs no card: 0.25 vCPU, a thousand API requests a day, 10 GB of storage. The first paid plan, Developer, is $49 a month. The downside of the metered model is the one every usage-billed analytics product shares: the bill scales with the exact thing a successful analytics product does more of. A dashboard that a lot of people load, or an endpoint that fans out across a large table, burns compute, and compute is the meter, so the bill moves with your traffic and is not easy to predict the month before it lands.

Layerbase is flat. ClickHouse is one of our Performance engines, which live on the Pro plan: $15/mo, up to 10 databases across the whole cloud engine catalog, and $10/mo pool blocks if you need more always-on capacity. There is no per-query charge, no vCPU-second meter, and no line item that grows because a query got popular. You size the instance, you pay the monthly price, and a viral dashboard changes your latency budget, not your invoice. Against a $49 entry point for Tinybird's first paid plan, flat $15 for the engine underneath it is a real gap.

This is the same reason people move to Layerbase from any metered database, and I have run the fuller version of that math before: a predictable bill you can put in a budget beats a variable one you reconcile after the fact.

What you give up by choosing Layerbase

An honest comparison has to say this plainly, because for some teams it is disqualifying.

• No managed ingestion connectors. Tinybird ships managed connectors for Kafka, S3, Google Cloud Storage, and DynamoDB, plus an HTTP Events API for streaming JSON in (warehouse sources like BigQuery and Snowflake flow through object storage staging). On Layerbase you load ClickHouse yourself, with the tools ClickHouse already has (INSERT, the HTTP interface, clickhouse-client, materialized views, table functions like s3() and url()).
• No auto-generated API layer. Tinybird's headline feature is turning a SQL pipe into a production HTTP endpoint with auth and rate limiting in one step. Layerbase does not do that. You put your own API in front, or query ClickHouse directly from your backend.
• No branching on ClickHouse. Layerbase branches nine engines copy-on-write, but ClickHouse is not one of them today. If ClickHouse branching is what you came for, it is not here yet. (If you want branchable analytics, DuckDB on Layerbase does branch.)

If your team wants the managed pipeline and does not want to build or operate the API and ingestion layer, that is a real reason to pay Tinybird for it. Buying that pipeline is a legitimate choice.

What you gain

• Real ClickHouse, not an abstraction over it. A native connection string means no proprietary API surface to design around and nothing to rewrite if you leave. Your queries are ClickHouse SQL, portable to any ClickHouse anywhere.
• A bill you can predict. Flat monthly, no usage meter on queries or scans.
• One account for everything else. ClickHouse for analytics sits next to Postgres, Redis, and the rest of a 20+ engine catalog on the same login and the same predictable bill, so the operational-analytics half of your stack and the transactional half live in one place.
• No lock-in. Because you hold a standard ClickHouse endpoint, moving on is a clickhouse-client dump and restore, not a rewrite of an API layer.

When Tinybird is still the right call

Use Tinybird when the pipeline is the point: you want managed ingestion, SQL-to-endpoint APIs, and analytics observability handed to you, and you would rather pay by usage than build and run that layer. A workload that fits inside the free tier's caps is genuinely free, and free beats any flat plan. Just know where the cliff is: the moment you outgrow those caps, the first paid dollar is $49 a month.

When Layerbase is the right call

Choose Layerbase when you want ClickHouse the engine, a flat and predictable bill, and no proprietary layer between your code and your data, and you are comfortable owning the API and ingestion yourself (which, if you have a backend already, you mostly do). It is also the obvious pick when ClickHouse is one engine in a larger stack you would rather run on one account than spread across a database provider plus a separate analytics vendor.

Trying it

You can create a managed ClickHouse database on Layerbase, get a connection string, and point clickhouse-client at it. Provisioning takes a minute or two; ClickHouse is a large binary. If it fits, it stays $15/mo on Pro no matter how many dashboards hit it. If it does not, you leave with a standard ClickHouse dump and owe nothing to a proprietary format.

That is the whole pitch: the same engine Tinybird is built on, priced so success does not surprise you, with the pipeline left in your hands instead of theirs.