How do Datadog, Grafana Cloud and self-hosted pricing models differ?

The three options differ less in price per unit than in what they count, and that determines which part of your growth gets expensive.

Option Primary billing units What you pay for indirectly
Datadog Per product: hosts (infrastructure, APM), log volume ingested and indexed, custom metrics Each new product or host multiplies across SKUs
Grafana Cloud Usage: active metric series, GB of logs and traces ingested, users; free tier available Assembly of dashboards, alerts and correlations
Self-hosted Compute, storage, network egress Engineering time to run, upgrade and scale it

Datadog sells separate products, each with its own meter. Teams choose it for the integrated UI, where a trace links to the host metrics and logs for the same request without extra wiring. The cost trade-off is that the bill grows along several axes at once. Adding hosts raises both infrastructure and APM charges, and new tags can create more custom metrics.

Grafana Cloud charges for usage on backends compatible with open-source query languages and protocols: PromQL for metrics, LogQL for logs and OTLP for ingestion. Your queries and instrumentation stay portable. In exchange, you do more of the assembly work yourself, such as building dashboards and connecting signals.

Self-hosted has no license fee. The cost moves to infrastructure and to the people who keep it running.

List prices change. Negotiated discounts, committed-use terms and bundling vary by customer, so confirm current rates on each vendor's pricing page before you model anything.

Who should use this cost model?

The model is for engineers and platform teams who have to defend an observability budget with numbers from their own systems, not from a vendor calculator's defaults. It is most useful in these situations:

  • You are choosing a first backend and want to know which billing unit your workload will stress most: hosts, series, log GB or spans.
  • A renewal is coming up and you need to check whether your committed volumes still match actual usage, or whether a move is worth pricing.
  • Your bill jumped unexpectedly and you need to trace the increase to a driver, such as a new label, debug logging or an autoscaling change.
  • You are weighing self-hosting and need to put engineering time on the same page as license and usage fees.

It assumes you already collect some telemetry, or can run a trial, so you can measure series counts, log volume and span rates. If you have no production telemetry yet, start with a small trial on one representative service and extrapolate, keeping in mind that cardinality rarely grows linearly with service count.

It is less useful for very small setups that fit comfortably inside a free tier. There, the deciding factors are usually features and team familiarity, not cost.

What actually drives observability cost?

The same workload can produce very different bills because each vendor counts different units. The shape of your telemetry matters more than the list price.

Metric cardinality. A series is one unique combination of metric name and label values, so series count is the product of distinct values per label. Adding a high-cardinality label such as user ID or request ID multiplies that product.

Illustrative estimate (assumed numbers, not a benchmark): series = endpoints × status codes × regions × other label values. With 20 × 5 × 3 = 300 series, adding a user_id label with 10,000 values gives 300 × 10,000 = 3,000,000 series.

Logs. Ingest, indexing and retention are often priced separately. Shipping logs is usually cheaper than making them searchable for 30 days.

Traces. Span volume grows with request rate, and the sampling rate decides how much of it you keep.

Churn. When autoscaling replaces short-lived nodes and containers, each new one can count toward host-based billing.

Seats. Some plans charge per user, so cost grows with team size even when telemetry volume stays flat.

Driver Datadog (typical unit) Grafana Cloud (typical unit) Self-hosted
Cardinality Custom metrics (name + tag combination) Active series Memory and storage per series
Logs GB ingested, events indexed, retention tier GB ingested, retention Disk, index size, query compute
Traces APM hosts, ingested and indexed spans GB ingested Storage, collector compute
Retention Longer tiers cost more Plan or add-on Disk
Churn Host count Mostly indirect, via series and volume Indirect
Seats Some products Active users None

How does the cost model work?

Every observability bill follows the same path. Telemetry is produced by instrumented services, passes through an agent or collector, and lands in a backend that meters it. The model mirrors that path in three steps.

  1. Measure what your services emit. Count active series, daily log GB, spans per second after sampling, peak hosts, and retention per signal. These numbers describe your workload and stay the same no matter which vendor you price.
  2. Translate them into each vendor's billing units. The same telemetry becomes different units depending on the meter. 80 peak hosts matter a great deal under per-host billing and barely at all under usage billing. 400,000 active series map directly to Grafana Cloud's series meter, while Datadog applies its own custom-metric counting rules. Logs may be split into an ingested part and an indexed part.
  3. Multiply by rates and add overage. Monthly cost is the sum of units × rate for each meter, plus any overage when usage at peak exceeds your committed volume. For self-hosting, the "rates" are compute, storage and engineer-hours.

The structure matters more than the exact figures. Once inputs and unit mappings are written down, you can change one assumption, such as a new label, a higher sampling rate or longer retention, and see which vendor's bill moves and by how much. The next section shows how to collect the inputs and turn them into a working model.

How do you build a cost model from your own telemetry?

Pull each input from the telemetry you already collect. Vendor calculators are only as accurate as these numbers.

  1. Active series. Count series per metric name over a representative day, for example topk(20, count by (__name__)({__name__=~".+"})). A handful of high-cardinality metrics usually dominate, and they are your first reduction targets.
  2. Daily log GB by source. Measure at the collector, before any vendor-side filtering. You need volume per service so you can decide which logs to index and which to only archive.
  3. Spans per second after sampling. Use post-sampling throughput and average span size, because that is what crosses the wire.
  4. Hosts and containers at peak. Host-based billing tends to follow high-water marks, so an average undercounts autoscaling.
  5. Retention per signal. Longer retention raises price tiers or disk.

Illustrative estimate (assumed numbers, not a benchmark). Assume a 50-host fleet that peaks at 80 hosts, 400,000 active series, 60 GB of logs per day with 20% indexed, and 2,000 spans/s at about 1 KB each (≈173 GB/day).

Input Datadog unit Grafana Cloud unit Self-hosted unit
Hosts 80 infra/APM hosts × R_host Not billed directly Collector compute
Metrics Custom metric combinations × R_cm 400k series × R_series Disk + memory
Logs 1,800 GB ingested × R_ingest, plus indexed events × R_index 1,800 GB × R_logs Storage
Traces ~5,200 GB ingested × R_span ~5,200 GB × R_trace Storage

Monthly cost = Σ (units × rate) + overage at peak. Replace each R_* with your quoted rate. Datadog's custom-metric count depends on its own counting rules, so get it from a trial rather than assuming it equals your series count.

DAYS = 30
PEAK_HOSTS = 80              # high-water mark, not the 50-host average
ACTIVE_SERIES = 400_000      # from count by (__name__) over a representative day
LOG_GB_PER_DAY = 60          # measured at the collector, before vendor filtering
INDEXED_FRACTION = 0.20      # share of logs you choose to index
AVG_LOG_EVENT_KB = 1.0       # assumption, used to convert GB to indexed events
SPANS_PER_SEC = 2_000        # after sampling
AVG_SPAN_KB = 1.0            # assumption

R = {"R_host": 0.0, "R_cm": 0.0, "R_ingest": 0.0, "R_index": 0.0,
     "R_span": 0.0, "R_series": 0.0, "R_logs": 0.0, "R_trace": 0.0}

log_gb = LOG_GB_PER_DAY * DAYS                                # 1,800 GB
indexed_gb = log_gb * INDEXED_FRACTION                        # 360 GB
indexed_events_m = indexed_gb * 1_000_000 / AVG_LOG_EVENT_KB / 1_000_000  # millions of events
span_gb = SPANS_PER_SEC * 86_400 * DAYS * AVG_SPAN_KB / 1_000_000  # ~5,184 GB

DD_CUSTOM_METRICS = ACTIVE_SERIES  # placeholder only, replace with trial figure

datadog = (PEAK_HOSTS * R["R_host"] + DD_CUSTOM_METRICS * R["R_cm"]
           + log_gb * R["R_ingest"] + indexed_events_m * R["R_index"]
           + span_gb * R["R_span"])
grafana = (ACTIVE_SERIES * R["R_series"] + log_gb * R["R_logs"]
           + span_gb * R["R_trace"])

print(f"Logs ingested: {log_gb:,.0f} GB, indexed: {indexed_gb:,.0f} GB "
      f"(~{indexed_events_m:,.0f}M events)")
print(f"Traces ingested: {span_gb:,.0f} GB")
print(f"Datadog monthly (illustrative): {datadog:,.2f}")
print(f"Grafana Cloud monthly (illustrative): {grafana:,.2f}")

A small Python model that turns the assumed 50-host fleet inputs into hosts, series, ingested and indexed log volume, and trace GB, then multiplies each by placeholder R_ rates to produce an illustrative monthly estimate per vendor.*

What does self-hosting observability really cost in engineering time?

A typical self-hosted stack has Prometheus, or a horizontally scalable metrics store when one Prometheus is not enough, Loki or Elasticsearch/OpenSearch for logs, Tempo or Jaeger for traces, and Grafana on top. The software is free. The cost is the compute, the object storage, and the people who keep it running.

Illustrative estimate (assumed numbers, not a benchmark)

monthly cost = infrastructure + (engineer-hours × loaded hourly rate)

Work item Assumed hours/month Why it takes time
Upgrades and config changes 8 Components ship on separate release cycles
Capacity planning and retention tuning 6 Ingest grows with every new service
HA and long-term storage operations 10 Replication, compaction and object-store lifecycle
On-call for the monitoring stack 12 Its pages land on top of product pages
Meta-monitoring 4 Something independent must watch the watcher
Total 40

At an assumed loaded rate of $100/hour, this adds $4,000/month to your infrastructure spend before you compare it with a vendor quote.

The main risk is correlated failure. An incident that spikes traffic also spikes log and trace volume. Ingesters run out of memory, and you lose visibility at the moment you need it. Meta-monitoring should therefore run on separate infrastructure. Teams also tend to underestimate HA and long-term storage, because both look easy on a small test cluster and get hard at production scale.

Migration in either direction has its own cost:

  • Re-instrumenting services
  • Rebuilding dashboards and alerts
  • Retraining engineers
  • Running both systems in parallel until the new one is trusted

Budget for this as a one-time cost alongside the monthly figure.

How can OpenTelemetry cut observability costs and keep you vendor-neutral?

OpenTelemetry (OTel) lowers the re-instrumentation cost before you need to pay it. Services emit OTLP to a collector you run, and only the collector knows which backend receives the data. Changing vendors becomes a change to collector configuration, not a code change across every service.

 [service A] ──┐
 [service B] ──┼─OTLP─▶ [OTel Collector] ──metrics──▶ self-hosted store
 [service C] ──┘        filter → attributes        ├─traces───▶ managed backend
                        → tail sampling → batch    └─logs─────▶ managed backend

A minimal pipeline needs only the otlp receiver, the batch processor and an otlp exporter. Cost control comes from the processors you add between the receiver and the exporter:

  • Filter processor: drops data you never query, such as health-check spans or debug logs. This data never reaches a metered endpoint.
  • Attributes processor: removes or hashes high-cardinality labels, such as user IDs, before they multiply your series count.
  • Tail-sampling processor: decides which traces to keep after each trace completes. It can keep all errors and slow requests and only a fraction of normal traffic.

Because this logic lives in one place, you can run a hybrid setup or send a slice of traffic to a second backend for a trial. A credible exit option also strengthens your position at renewal.

OTel has limits. Dashboards, alerts and query languages stay backend-specific, and so do proprietary agent features such as profiling, security signals and automatic service maps. Those still create switching cost, so track how much you depend on them.

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

processors:
  # Batch before export to reduce request count and overhead.
  # Add filter, attributes and tail-sampling processors here for cost control.
  batch: {}

exporters:
  # Self-hosted metrics store that accepts OTLP (placeholder host).
  otlp/selfhosted:
    endpoint: metrics-store.internal.example:4317
    tls:
      insecure: true   # internal network only; enable TLS in production

  # Managed backend for traces and logs (placeholder endpoint and key).
  otlp/managed:
    endpoint: otlp.vendor.example.com:4317
    headers:
      api-key: ${env:MANAGED_BACKEND_API_KEY}

service:
  pipelines:
    # Switching vendors means editing these exporter lists, not service code.
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp/selfhosted]
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp/managed]
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp/managed]

A minimal collector config that receives OTLP from all services, batches it and sends metrics to a self-hosted store and traces and logs to a managed backend, so routing changes live in one file.

Which cost-control levers work with any vendor, and when do they hurt debugging?

These levers work the same whether you pay Datadog, Grafana Cloud or your own storage bill, because each one reduces data before it is stored.

Levers that apply everywhere

  • Drop high-cardinality labels at collection. In Prometheus, a metric_relabel_configs rule with action: labeldrop removes labels such as pod_uid or request_id after the scrape and before storage. Every unique label combination is a separate series, and most backends bill per series.
  • Aggregate before shipping. Rolling per-pod metrics up to per-service metrics in a collector or with recording rules sends far fewer series.
  • Choose a sampling mode. Head-based sampling is cheap but decides before the outcome is known. Tail-based sampling keeps errors and slow traces, but the collector must buffer complete traces.
  • Filter or route noisy logs before ingest, and use tiered retention. Archive cold logs to object storage.

Where bills surprise you

The usual causes are:

  • Autoscaling that inflates host counts.
  • A deploy that adds a user ID label.
  • Debug logging left on.
  • Integrations that create custom metrics implicitly.
  • Overage rates that exceed your committed-use price.

Alert on the telemetry itself. Track active series growth week over week and log GB per day per team, and page the owning team when either crosses its budget.

The trade-off

Heavy sampling, short retention and dropped labels can delete the evidence you need for a rare incident or a compliance audit. Cheaper per-unit pricing without per-team ownership and budgets just funds sprawl.

scrape_configs:
  - job_name: checkout-api
    static_configs:
      - targets: ['checkout-api.internal:9090']
    metric_relabel_configs:
      # Remove per-request and per-pod-instance labels. Only drop labels whose
      # removal still leaves each series unique, or samples will collide.
      - action: labeldrop
        regex: 'request_id|pod_uid'
      # Drop an entire debug histogram that no dashboard or alert uses.
      - source_labels: [__name__]
        action: drop
        regex: 'checkout_debug_latency_seconds_bucket'
---
groups:
  - name: telemetry-budget
    rules:
      - alert: ActiveSeriesGrowthWeekOverWeek
        # More than 20% growth versus the same time last week often means a
        # deploy added a high-cardinality label.
        expr: prometheus_tsdb_head_series / (prometheus_tsdb_head_series offset 1w) > 1.2
        for: 1h
        labels:
          severity: ticket
        annotations:
          summary: 'Active series up {{ $value | humanizePercentage }} of last week on {{ $labels.instance }}'

A Prometheus scrape config that uses metric_relabel_configs with labeldrop and drop to remove high-cardinality labels and an unused metric before storage, plus an alerting rule that flags active series growth of more than 20% week over week.

What are the alternatives to Datadog and Grafana Cloud?

The comparison above uses two managed vendors, but the cost model applies to any backend. Map your measured inputs to that backend's billing units the same way. The main alternatives fall into a few categories:

  • A fully self-hosted open-source stack. Prometheus or a horizontally scalable Prometheus-compatible store for metrics, Loki or Elasticsearch/OpenSearch for logs, Tempo or Jaeger for traces, and Grafana for dashboards. There is no license fee, but you take on the engineering time described in the self-hosting section.
  • Self-hosted Grafana stack components with your own object storage. This uses the same query languages as Grafana Cloud (PromQL, LogQL), so dashboards and alerts can move between the managed and self-hosted versions with less rework than a move to a different query language.
  • Your cloud provider's built-in monitoring service. These services are often the easiest place to start for infrastructure metrics and platform logs on that provider. They usually bill by ingested volume, stored metrics and API calls. Watch for weaker cross-cloud support and query models that are specific to that provider.
  • A hybrid split. Keep one signal self-hosted and send the others to a managed backend, with an OpenTelemetry Collector doing the routing. This works well when one signal dominates cost.
  • Reducing telemetry instead of switching. Sometimes the cheapest alternative is the same vendor with less data. Dropping labels, sampling traces and archiving cold logs can change the bill more than a migration would, and without the migration cost.

Whichever alternative you price, run it through the same steps: measure inputs, translate them to billing units, apply quoted rates, and add engineering time and one-time migration cost.

When should you choose Datadog, Grafana Cloud, self-hosted or a hybrid?

Treat the choice as a fit between your team's operating capacity and the shape of your telemetry, not as a search for the cheapest per-unit price.

Option Choose it when Avoid it when
Datadog (managed all-in-one) The team is small, time-to-value matters most, and you want APM, logs and infrastructure correlated out of the box Host counts or custom-metric cardinality grow unpredictably, or a multi-year commitment would lock you into volumes you can't forecast
Grafana Cloud (usage-based managed) You already run Prometheus, Loki or Tempo-style tooling and want to stop operating storage and retention yourself You need polished APM correlation with no assembly work on dashboards, trace-to-log links or service maps
Self-hosted Volume is large and stable, you have platform engineering capacity, or data residency rules out third-party storage No one can own on-call for the observability stack itself
Hybrid One signal dominates cost or risk and the others don't Splitting signals would break the correlation your incident workflow depends on

The "avoid" column carries most of the risk. Datadog's per-host and custom-metric billing punishes autoscaling spikes and label sprawl. Grafana Cloud's lower assembly cost assumes you're willing to wire signals together yourself. A self-hosted stack that pages nobody when ingestion falls over fails silently during the incident you need it for.

A common hybrid is self-hosted metrics with managed logs. Metric volume tends to be predictable and cheap to store in a time-series database you control. Log volume is bursty and operationally painful to retain and index, so a managed service is often the better fit for logs.

Rerun your cost model at every renewal and whenever telemetry shape changes, such as a new service mesh, a tracing rollout or a cardinality jump. The cheapest option for your stack today may not be the cheapest after the next architecture change.

How OneEnv can help

Disclosure: OneEnv is the product behind this blog.

OneEnv (oneenv.io) is a workspace-based governance platform for the things services share — environment variables, database structure, API routes and validation rules. A change to a shared value is staged on a branch, reviewed once, and then every affected service explicitly approves or rejects it before it goes live, so you can see who a change touches before it ships instead of finding out in production.

Applied to datadog vs grafana cloud cost, this is where it helps:

Saves time

  • Every service that inherits a shared value is listed in one place, so nobody searches repos and chats to find out who is affected.
  • One review per branch replaces coordinating each team separately; each service still keeps its own approve/reject.
  • Reviewers see the exact diff and the list of affected services up front, so approval is a decision rather than an investigation.

Saves cost

  • Fewer production incidents and rollbacks caused by a shared value, route or column changing under a consumer unannounced.
  • Less duplicated configuration to maintain: one shared definition inherited by many services.
  • Per-service approve/reject means a bad shared value can be refused where it would break something, before it is live.
  • OneEnv has a free plan (1 workspace, unlimited services and members, full governance), so trying it costs nothing.

These are qualitative benefits, not measured results — how much you save depends on how many services share the value.

Want to try it? Start at oneenv.io.