IBRAVRA Media Network
Comparisons • 12 min read

Jaeger vs Zipkin vs Tempo: Distributed Tracing Playbook

Jaeger, Zipkin, and Grafana Tempo all store the same spans, but the bill lands in different places: Jaeger and Zipkin charge you a database, Tempo charges you object storage, and Grafana Cloud charges you per gigabyte. The breakeven sits near 100 million spans a month.

By Enow A. Jovial • Published 2026-11-21

Three backends, one decision

Jaeger, Zipkin, and Grafana Tempo answer the same question — where do the spans go — with three different bargains. Jaeger is the full platform: one binary as collector, query, and ingester, backed by a database you operate. Zipkin is the oldest and simplest: four components, one Java jar, storage built on Cassandra. Tempo is the newest shape: a backend that needs only object storage and answers with TraceQL.

Tempo is the cheapest backend to operate because it replaces the database with object storage. Jaeger and Zipkin each need a database node as well, so their floor is roughly double Tempo’s. Grafana Cloud is cheapest below 50 GB a month, where the free tier is $0 — and it stays cheaper until 100 million spans a month.

What each backend actually is

Jaeger v2 ships as a single binary that runs as all-in-one, collector, query, or ingester. The container run exposes port 16686 for the UI, 4317 and 4318 for OTLP, and 9411, with a YAML file passed through the --config flag. Collector and query are stateless. Service maps need the spark-dependencies job.

Zipkin has four components: collector, storage, search, and web UI. Spans arrive by HTTP, Kafka, or Scribe, and are queried through a JSON API. The quickstart is one jar — java -jar zipkin.jar, JRE 17 or newer — at localhost:9411/zipkin. There is no built-in authentication in the UI, so an exposed Zipkin server needs a proxy or firewall in front of it.

Tempo is the outlier. Its own overview says it is cost-efficient and only requires an object storage to operate; its configuration reference lists Amazon S3, GCS, Azure, and the local filesystem, with Memcached or Redis to speed up queries. Tempo accepts Jaeger, Zipkin, and OpenTelemetry protocols, so an existing instrumented fleet can point at it without re-instrumenting.

Storage backends and retention

Jaeger requires a persistent backend: Cassandra, Elasticsearch, and OpenSearch are the primary backends; ClickHouse is experimental. For large-scale production the Jaeger team recommends OpenSearch over Cassandra. Jaeger splits storage into primary and archive: the primary store is typically run with a short TTL, for example two weeks, while the archive holds only traces a user saves manually from the UI.

Jaeger storage backends docs — Cassandra, Elasticsearch, and OpenSearch are the primary backends, ClickHouse is experimental, OpenSearch is recommended over Cassandra
Jaeger storage backends docs — Cassandra, Elasticsearch, and OpenSearch are the primary backends, ClickHouse is experimental, OpenSearch is recommended over Cassandra

Zipkin’s storage story is narrower and older. It was built on Cassandra, and natively supports Elasticsearch and MySQL. Cassandra needs 3.11.3 or newer; Elasticsearch is tested against versions 7 to 8 and OpenSearch 2. MySQL is a legacy v1 component with known performance issues — queries will eventually take seconds once the volume grows. Dependency links need the zipkin-dependencies Spark job; switching search off leaves traces retrievable by ID only.

Tempo’s storage model is a single formula from its own configuration documentation: ingested bytes per day times retention days equals stored bytes. Its default block retention is 336 hours — 14 days — set by the block_retention option, and blocks are capped at 100 GiB by default. That is why Tempo’s bill is lower: stateless compute plus a bucket.

DimensionJaegerZipkinTempo
StorageCassandra, Elasticsearch, OpenSearchCassandra, Elasticsearch, MySQL (legacy)S3, GCS, Azure, local filesystem
RetentionShort TTL (e.g. two weeks)Limited TTL; QUERY_LOOKBACK 24h336h (14 days)
Authorityjaegertracing.io/docs/2.23/storagezipkin.io architecture; openzipkin READMEgrafana.com/docs/tempo/configuration

Sampling: the dial that sets the bill

Sampling decides the monthly cost: every span that survives must be stored and retained. Head-based sampling decides at the start of the trace, in the OpenTelemetry SDKs. Tail-based sampling decides after the trace completes, so it can keep every error trace — but the application must export all traces, and the backend pays higher memory and processing costs. Remote sampling centralises the policy: probabilistic at 0.1 keeps about 1 in 10 traces; rate limiting at 2.0 keeps 2 per second.

Zipkin’s sampling is one knob: COLLECTOR_SAMPLE_RATE, the percentage of traces to retain, defaulting to 1.0 — keep everything. It is a head-based decision at ingest, and the server has no tail-based stage. Tempo has no sampling knob of its own: the decision is made upstream, in the SDK or the Collector, and Tempo stores what arrives.

The table below prices sampling at 100 million produced spans a month, at the 1 KB per span assumption stated in the next section, on Grafana Cloud Pro.

Sampling rateSpans stored per monthGB ingestedGrafana Cloud Pro monthly cost
100%100,000,000100$44.00
10%10,000,00010$19.50
1%1,000,0001$19.05
0.1% (Jaeger default)100,0000.1$19.01
Sampling saving 100% to 1%=$44.00−$19.05$44.00=56.7%\text{Sampling saving 100\% to 1\%} = \frac{\$44.00 - \$19.05}{\$44.00} = 56.7\%

Query cost: finding the trace is the second bill

Finding the trace is the second bill. Tempo’s answer is TraceQL, a query language modelled on PromQL and LogQL that selects traces by span attributes. TraceQL requires Parquet, Tempo’s default block format, and TraceQL metrics can generate metrics for alerting. There is no separate index to pay for.

Jaeger’s query path is the UI and API on port 16686, with Service Performance Monitoring for rate, errors, and duration. Zipkin’s query is simpler: find traces by service, operation, tags, and duration, or jump to one from a log-file trace ID. The dependency diagram needs the zipkin-dependencies Spark job. Switching search off cuts storage and write load, but the UI then only opens traces by ID.

What Grafana Cloud Traces costs

Grafana Cloud Traces is Tempo as a managed service, priced in three parts. The free tier is $0 with 50 GB a month and 14-day retention. Pro carries a $19 monthly platform fee including 50 GB a month, with 30-day retention. Usage rates are $0.05 per GB to process, $0.40 to write, and $0.10 to retain. Enterprise is custom, with a $25,000-a-year minimum commitment. The page’s FAQ defines the three lines: process receives and optimises signals; write stores only useful data; retain protects stored data.

Grafana Cloud Traces pricing — free tier 50 GB a month, 14-day retention; Pro $0.05 process, $0.40 write, $0.10 retain per GB, $19 platform fee including 50 GB
Grafana Cloud Traces pricing — free tier 50 GB a month, 14-day retention; Pro $0.05 process, $0.40 write, $0.10 retain per GB, $19 platform fee including 50 GB

First, this article charges process at $0.05 on every ingested gigabyte and write at $0.40 only above 50 GB; if an invoice waives process inside the 50 GB, subtract $0.05 times the smaller of volume and 50. Second, the retain line prices retention beyond the included 30 days, so the primary model uses the default 30-day retention at $0.45 per GB all in, and shows $0.55 per GB as the upper bound.

One span is modelled as 1 KB of stored trace data — a stated assumption. Real spans vary, so measure your own export. At that conversion, 10 million spans is 10 GB, 100 million is 100 GB, and 1 billion is 1,000 GB a month.

Spans per monthGB ingestedGrafana Cloud FreeGrafana Cloud ProPro, upper bound with retain
10,000,00010$0$19.50$20.50
100,000,000100Over the 50 GB limit$44.00$54.00
1,000,000,0001,000Over the 50 GB limit$449.00$549.00
Managed monthly cost=$19+$0.05×V+$0.40×max⁡(0,V−50)\text{Managed monthly cost} = \$19 + \$0.05 \times V + \$0.40 \times \max(0, V - 50)
Cost per million spans, managed=$19.5010=$1.95 at 10M, $44.00100=$0.44 at 100M, $449.001,000=$0.45 at 1B\text{Cost per million spans, managed} = \frac{\$19.50}{10} = \$1.95 \text{ at 10M, } \frac{\$44.00}{100} = \$0.44 \text{ at 100M, } \frac{\$449.00}{1{,}000} = \$0.45 \text{ at 1B}

The self-hosted math

Self-hosted cost is compute plus storage. Compute is one stated assumption: a 4 vCPU, 8 GB server at $40 a month. Storage is priced from a vendor page opened this cycle: Hetzner Object Storage charges €6.49 a month, including 1 TB of storage and egress; over-quota storage is €0.0087 per TB-hour — €6.47 per TB-month. At a stated €1 = $1.16, the base is about $7.53 a month.

Tempo’s self-hosted total is the compute server plus the object-storage base, because Tempo needs only object storage:

Tempo self-hosted=$40+€6.49≈$40+$7.53=$47.53 per month\text{Tempo self-hosted} = \$40 + €6.49 \approx \$40 + \$7.53 = \$47.53\text{ per month}

That total holds at all three volumes: stored bytes stay under the included 1 TB until about 2,143 GB ingested a month. Jaeger and Zipkin cost more: the database is a second server, $40 for the backend plus $40 for the database node, or $80 a month before the database disk — the database is the cost that scales, not the backend.

Retention is where the self-hosted bill moves. Extending Tempo from 14 days to 90 days at 1,000 GB ingested a month stores 3,000 GB against the 1 TB included, so two extra terabytes at €6.47 each add €12.94, taking storage to €19.44, about $22.55, and the monthly total to $62.55.

Tempo 90-day storage=€6.49+2×€6.47=€19.44≈$22.55,total=$40+$22.55=$62.55\text{Tempo 90-day storage} = €6.49 + 2 \times €6.47 = €19.44 \approx \$22.55, \quad \text{total} = \$40 + \$22.55 = \$62.55

The breakeven is where the managed formula meets $47.53: about 108 GB ingested a month on the primary model, about 88 GB on the upper-bound model. Below that band, Grafana Cloud is cheaper — and below 50 GB a month the free tier is $0. Above it, self-hosted Tempo wins: at 1 billion spans the managed bill is $449.00 against $47.53 self-hosted, a 9.4-times difference.

Breakeven, primary=$47.53+$1$0.45=108 GB per month≈108M spans\text{Breakeven, primary} = \frac{\$47.53 + \$1}{\$0.45} = 108\text{ GB per month} \approx 108\text{M spans}
Breakeven, upper bound=$47.53+$1$0.55=88 GB per month≈88M spans\text{Breakeven, upper bound} = \frac{\$47.53 + \$1}{\$0.55} = 88\text{ GB per month} \approx 88\text{M spans}

The decision

DimensionJaegerZipkinTempo / Grafana CloudAuthority
Monthly cost$80 + disk$80 + disk$44.00 / $449.00 managed; $47.53 self-hostedGrafana; Hetzner pricing
StorageCassandra, Elasticsearch, OpenSearchCassandra, Elasticsearch, MySQLS3, GCS, Azure; no databaseCited docs
RetentionShort TTL, e.g. two weeks, plus archiveLimited TTL; 24h lookback336h (14 days)Jaeger; Zipkin; Tempo docs
SamplingHead, tail, remote, adaptiveSample rate, 1.0 default, head-basedDecided upstream in SDK/CollectorJaeger; Zipkin docs
QueryUI + API; SPM needs storeUI + JSON API; dependency job neededTraceQL on ParquetCited docs
Zipkin’s UI ships with no built-in authentication, and its server defaults to keeping 100% of traces. A Zipkin jar started with defaults and left reachable on a network is an open trace browser holding every request your services made, at full volume. Put a proxy with authentication in front of it on day one, and set COLLECTOR_SAMPLE_RATE before the first production deploy, not after the disk fills.

Who should not pick each one

Do not pick Jaeger without a database operator: every span lands in Cassandra, Elasticsearch, or OpenSearch, so the team adopts two systems, not one. Do not pick Zipkin for large volumes or long retention: MySQL is legacy, and the default sample rate of 1.0 keeps everything. Do not pick Tempo self-hosted if nobody owns the bucket, the retention, and the upgrades — a 14-day default still deletes last month’s incident traces. Do not pick Grafana Cloud above roughly 100 million spans a month if the team already operates infrastructure: there the managed bill is nine times the self-hosted bill.

Run the switch

  1. Measure the span size: export one day of spans; divide bytes by span count.
  2. Set the sampling policy: pick the rate per service — 100% for payments, 1% for health checks.
  3. Size the retention first: decide the incident window — 14, 30, or 90 days.
  4. Stand up the backend beside the current one: run the new backend in parallel for one incident cycle.
  5. Point the collectors: change the exporter endpoint in the Collector or agent configuration.
  6. Verify the query path: run the three queries the team uses and confirm each answers.
  7. Confirm the retention clock: check old blocks are deleted on schedule.
  8. Cut over and watch the bill: compare the first bill against the model and record the variance.
  • [x] Real span size measured; 1 KB assumption replaced.
  • [x] Sampling policy recorded per service.
  • [x] Retention window decided; stored bytes computed.
  • [x] Three real queries verified before cutover.
  • [x] Retention deletion confirmed; archive holds incident traces.
  • [x] First bill compared against the model; variance recorded.

Failure modes

Most tracing migrations fail on the meter. The 100% default: a Zipkin deploy left at COLLECTOR_SAMPLE_RATE 1.0 stores every span until the disk fills. The tail-sampling trap: a Jaeger team enables tail sampling without sizing memory — the application must record and export all traces first. The retention surprise: a team needing 90 days discovers Tempo’s 14-day default only after the traces are gone. The index bill: a Jaeger team on Elasticsearch that never configures rollover or ILM watches daily indices pile up. Each is preventable by setting sampling, retention, and authentication before the first production span.

Founder & CEO Insight — Enow A. Jovial

"Tracing is the cheapest observability decision a founder makes and the most expensive to reverse. The backend is free until the day you need the trace it deleted — and by then the incident is over and the evidence is gone. Pay for the retention and the sampling policy up front, while the choice is still cheap." — Enow A. Jovial, Founder & Chief Executive Officer
Set the sampling rate before the first production deploy, and size the tier on the busiest month, not the average. A 1% sample rate on a 100-million-span fleet cuts the Grafana Cloud bill from $44.00 to $19.05 — and the traces you keep are the ones you chose, not the ones that happened to fit.

Measure, sample, size retention, run in parallel, verify queries, then cut over. The pipeline behind these backends is our OpenTelemetry Collector versus Datadog Agent versus Grafana Alloy guide; the managed trio: our Datadog versus Grafana Cloud versus New Relic guide; the error-tracking comparison: our Sentry versus Grafana versus Honeycomb guide. Before the next renewal, run the numbers through our pricing calculator to confirm the volume sits on the right side of the breakeven.