Self-hosting the observability stack: the real math.

Once you put an AI in front of customers, you have to be able to see what it did — every prompt, every tool call, every answer, replayable after the fact. That's LLM observability, and the open-source standard for it is Langfuse. The catch that surprises everyone is the pricing shape: like most tracing platforms, it's metered per unit — a "unit" is one trace, one observation, or one score ingested — and a chatty agent emits a startling number of those per conversation. So we did the arithmetic on self-hosting it instead of buying the cloud, and the answer is more interesting than "cheaper." The bill favors self-hosting at volume, clearly. But the number on the invoice is the least important input to the decision.

Here's the honest version up front: self-hosting a tracing stack is roughly 4–6× cheaper at real volume, and the reason to do it anyway isn't the money — it's that your traces are full of your customers' words, and running your own database is a new job you can't hand back.

What you're actually running

"Just self-host it" hides a stack. The current-generation architecture (Langfuse v3, as of mid-2026) is deliberately not a single box, because the workload has two very different halves — transactional bookkeeping and enormous append-only analytics — and one database can't do both well. So it splits into a handful of parts:

Two stateless services — a web app and an async worker — and a spread of stateful ones behind them. Postgres holds the transactional metadata. Redis carries the ingestion queue and cache. ClickHouse holds the traces themselves — the columnar analytics database that the whole design pivots around, because Postgres buckled on both ingest and query once the trace tables hit millions of rows (Langfuse + ClickHouse, 2024). And blob storage keeps the raw events and large multimodal payloads. The worker exists precisely so that a burst of traffic doesn't stall the app: events land on the Redis queue and get upserted into ClickHouse asynchronously (Langfuse self-hosting docs, 2026).

None of these is exotic on its own. The point is that "self-host the tracer" means "operate six things," and one of them is a database most small teams have never run in production.

The cloud meter, worked out

The metered model is simple to state and easy to under-estimate. The published rate (as of mid-2026) is on the order of $8 per 100,000 units beyond a plan's included allotment, on top of a modest monthly base (Langfuse pricing teardowns, 2026). A unit, again, is a single trace, observation, or score.

The trap is that one AI conversation is not one unit. A single grounded answer with a couple of tool calls easily fans out into a dozen-plus observations — the top-level trace, each model call, each retrieval, each score you attach for quality. So a support agent doing real work generates units at a multiple of the conversations it handles. Run the tape forward to a busy month — call it 10 million observations — and the meter reads about $731 for the month:

Against that, the self-hosted stack is a flat line: one managed Kubernetes cluster running those six components, all-in, lands somewhere around $100–175 a month and, crucially, doesn't move when your traffic spikes. That's the 4–6× gap, and it widens as you grow, because one side is a fixed cluster and the other is a meter. A flat cost you can forecast beats a metered one you can only apologize for.

Where the crossover actually is

The bars make self-hosting look like an obvious win, but the crossover has a real location, and below it the cloud is the right answer without debate. If you're doing under a few million units a month, the metered cloud bill is small — often well under the base fee's worth of overage — and the operational time to run ClickHouse yourself dwarfs any saving. The published guidance says as much: for teams under roughly 5 million events a month with no data-residency needs, the hosted option is almost always the better deal once you price in the ops time (Langfuse pricing analysis, 2026).

So the money argument is real but conditional: self-hosting only pays once your trace volume is both high and steady. A spiky, low, or unpredictable volume is exactly the shape the cloud meter is good at, and exactly the shape where standing up a database cluster is a waste of a founder's week.

The decider isn't the money

Here's the part the spreadsheet misses. A trace of a support AI is not an abstract metric — it is the verbatim customer conversation, plus whatever the AI retrieved to answer it. The refund someone asked for, the account they couldn't access, the frustration in their phrasing. When you send your traces to a managed cloud, you are shipping the raw text of your customers' support interactions to a third party's database, wherever that database physically sits.

For a lot of businesses that's fine. For some — regulated ones, ones with data-residency obligations, ones that simply promised their users the conversation stays in-house — it is not, and no discount changes that. Data sovereignty is the argument that survives even when the cloud is cheaper, because it isn't an argument about cost at all. If the traces contain things you can't legally or ethically hand to a vendor, the metered bill is irrelevant; self-hosting isn't the frugal choice, it's the only choice.

The honest cost of "free"

And then the counterweight, stated plainly because a Real Numbers post that only counts dollars is lying by omission. Self-hosting doesn't cost $100–175 a month. It costs $100–175 a month plus a new thing that can page you at 3am.

That thing is ClickHouse. The web app and worker are ordinary stateless services a small team already knows how to run. ClickHouse is a columnar database with its own operational personality — its own backup story, its own upgrade path, its own failure modes, its own capacity cliffs when the trace volume climbs. The moment you self-host, you have quietly hired yourself as its database administrator. For a team of one or two, that is not a footnote; it's the whole decision. The flat bill buys you a database to operate, and operations is a cost that doesn't show up until the night it does.

How we think about it

The framing we keep coming back to: metered cloud tracing is a fantastic deal until two things are both true — your volume is high and steady enough that the meter hurts, and your traces are sensitive enough that where they live is a real question. When only the first is true, you're weighing dollars against ops time, and for a small team ops time usually wins, so you stay on the cloud longer than the spreadsheet suggests. When the second is true, the dollars stop mattering and sovereignty decides it.

That's the same discipline we apply to everything the AI touches: keep the sensitive data close, keep the moving parts to the minimum that does the job, and never take on a 3am surface without pricing the 3am, not just the invoice. Observability is where you go to trust an AI in production — and the irony worth sitting with is that the tool for watching your customers' conversations is itself a decision about who gets to watch your customers' conversations. Count the units, then count the things that aren't on the invoice — the sovereignty you keep and the database you now own.