Datadog vs Grafana Cloud vs self-hosted Grafana: the mid-market observability cost decision

Observability is the second-largest cloud line item in roughly half of the mid-market engagements we run. It rarely starts that way. A team picks Datadog in year one because it works in an afternoon, ingests three months of logs without complaint, and the bill is a rounding error on the compute spend. Two years later the workload count has tripled, log retention is now a compliance commitment, and the observability invoice is larger than the RDS bill. At that point the question is no longer "which platform is easiest" — it is "which platform's pricing model survives the next 18 months of growth without forcing a migration."

This piece walks through the cost math for the three realistic mid-market choices: Datadog SaaS, Grafana Cloud, and self-hosted Grafana with Loki, Mimir, and Tempo. We use three concrete environment sizes — 100 hosts, 500 hosts, 2,000 hosts — because the answer changes meaningfully at each tier. We are vendor-neutral; we run engagements on all three patterns and have seen each succeed and fail.

All pricing figures are published rates as of mid-2026. Vendor pricing pages change; verify directly before you put a number in front of finance.

Why observability cost surprises happen

The pattern we see almost every time:

1. Initial procurement is based on host count. A platform team estimates 100 hosts, looks at the host-based line item on the pricing page, and buys against that number.
2. The real bill is driven by logs, custom metrics, and traces — none of which scale with host count. They scale with application behavior, which the platform team does not control.
3. Twelve to eighteen months in, the invoice is 3-5x the original estimate. The platform lead is now in a quarterly meeting explaining the variance.

Datadog, Grafana Cloud, New Relic, Honeycomb — they all have this dynamic, with different mechanics. The platforms are not deceiving anyone. The pricing pages are clear if you read them carefully. The issue is that mid-market platform teams almost never have a baseline of how many custom metrics, log GBs, and traces their applications will produce a year out. The first invoice is honest; it is the trajectory that is the surprise.

For a refresher on what a healthy observability stack actually does, see our guide to observability for microservices. This piece is the cost-economics companion to that one.

The three options, defined

Datadog (SaaS). Full-stack observability platform. You install the agent on your hosts, point your logs and traces at the SaaS endpoint, and use the Datadog UI. Pricing is a layered mix of per-host APM, per-GB log ingest with separate indexed-retention pricing, per-custom-metric pricing (with allowances attached to the Infrastructure tier, not APM), and per-million-trace-span pricing. Log ingest itself is tier-dependent: Forwarding, Standard Indexing, and Flex Logs each carry different ingest and retention economics. Datadog public pricing: https://www.datadoghq.com/pricing/.

Grafana Cloud (SaaS). Hosted version of the Grafana open-source stack — Loki for logs, Mimir for metrics, Tempo for traces, Grafana for the UI. Pricing on the Pro tier is a $19/month platform fee plus usage-based components: per active series for metrics ($6.50 per 1,000 series), a three-part rate for logs and traces (Process, Write, Retain), with included free allowances (10,000 active series and 50 GB of logs / traces / profiles per month) before overage kicks in. Grafana Cloud public pricing: https://grafana.com/pricing/.

Self-hosted Grafana + Loki + Mimir + Tempo. You run the same open-source stack yourself, typically on EKS / GKE / AKS, with object storage (S3, GCS, Azure Blob) as the backend. Mimir is the recommended metrics backend at scale (Prometheus is the upstream OSS project that Mimir extends for horizontal scale and long-term storage). There is no software license. The cost is the underlying infrastructure plus the engineering time to run it.

For honest comparison we also note:

• New Relic. Different pricing model — user-based plus per-GB ingest. Strong APM, simpler pricing logic than Datadog at high volume. New Relic was taken private in November 2023 in a $6.5B transaction led by Francisco Partners and TPG Inc. (announced July 2023). Pricing direction since has been steady rather than disruptive. New Relic pricing: https://newrelic.com/pricing. We see it most often at organizations with smaller engineering teams where the per-user fee is acceptable.
• Honeycomb. Event-based pricing optimized for tracing-first observability. Honeycomb pricing: https://www.honeycomb.io/pricing. Well-regarded for distributed systems debugging; pricing scales more predictably than Datadog at high trace volumes.
• Splunk. Now Cisco Splunk following the 2024 acquisition. Strong logging and SIEM heritage; pricing has historically been opaque and enterprise-oriented. We see it in regulated environments more than greenfield mid-market deployments.

The three primary options below cover roughly 85% of the mid-market platform choices we encounter. The others are real and worth evaluating; they are not the typical default.

TL;DR: which option fits which tier

The rest of the piece shows the cost math behind these recommendations.

Tier 1: ~100 hosts

A representative profile at this scale: 100 hosts (a mix of EKS nodes and a few VMs), 40 GB/day of logs, 200 custom metrics per host, modest APM coverage on 30 services, and a small distributed tracing footprint.

Datadog estimate (list price, mid-2026):

• APM at $31/host/month x 100 hosts = $3,100/month (annual billing; on-demand pricing is higher — verify the current delta with Datadog).
• Infrastructure monitoring (bundled in many APM tiers; standalone Infrastructure Pro is $15/host/month) — assume bundled for this profile.
• Log ingestion: 40 GB/day x 30 days = 1,200 GB/month. List rate around $0.10/GB ingested = $120/month, but the indexing/retention SKU you pick (Forwarding vs Standard Indexing vs Flex Logs) drives most of the bill. Indexed retention at 15 days on Standard adds roughly $1.70 per million log events; at 1,200 GB/month with typical event sizes, that lands around $700-900/month for typical retention.
• Custom metrics: 200 metrics/host x 100 hosts = 20,000 custom metrics. The Infrastructure tier includes 100 custom metrics per host on Infra Pro (200/host on Enterprise), so on Infra Pro the allowance is ~10,000 with ~10,000 overage. Datadog now directs custom-metric overage pricing to sales; the historical reference rate is $0.05/metric/month, but verify the current rate with Datadog. At the historical rate, the overage adds ~$500/month.

Rough monthly total: $4,400-$4,700/month, or $53k-$56k/year.

Grafana Cloud estimate (Pro tier, list price):

• Platform fee: $19/month.
• Metrics: 100 hosts producing roughly 80,000-150,000 active series total. Pro includes 10,000 active series free; assume 100,000 series total = 90,000 overage at $6.50 per 1,000 series = ~$585/month.
• Logs: 1,200 GB/month at the three-part rate ($0.05/GB Process + $0.40/GB Write + $0.10/GB Retain at default retention = ~$0.55/GB combined). Pro includes 50 GB of logs free; 1,150 GB overage at ~$0.55/GB = ~$633/month. Effective rate varies with retention configuration.
• Traces: modest volume; typically inside the free 50 GB allowance at this profile = $0-100/month.
• Users: Grafana Cloud Pro users are included in the platform fee for the standard quota; budget add-ons only if you exceed the included seat count.

Rough monthly total: $1,250-$1,500/month, or $15k-$18k/year.

Self-hosted estimate:

• Infrastructure: 3-4 EKS nodes for the observability stack (Loki, Mimir, Tempo, Grafana, alerting), plus S3 for log/trace storage. Roughly $800-1,200/month on AWS.
• Engineering time: 10-15% of one platform engineer at this scale, mostly during incidents and quarterly upgrades. Loaded cost roughly $2,000-3,000/month.

Rough monthly total (cash + loaded labor): $2,800-$4,200/month, or $34k-$50k/year.

At this tier, the verdict is uncomfortable for self-hosting advocates. Grafana Cloud is the lowest total cost, often by a meaningful margin. Datadog is more expensive but offers a UI and APM depth that some teams find worth the premium. Self-hosting is competitive on cash but loses on total cost once you account for the engineer time, and at 100 hosts you usually don't have a spare 10-15% of a platform engineer.

Tier 2: ~500 hosts

Profile: 500 hosts, 250 GB/day of logs, 300 custom metrics per host, APM on 80 services, distributed tracing across most of the production path.

Datadog estimate:

• APM: 500 hosts x $31 = $15,500/month.
• Logs: 7,500 GB/month at $0.10/GB ingest = $750/month, plus indexed retention — realistically $4,000-5,500/month at typical retention windows and event sizes on Standard Indexing. Flex Logs trades indexed-query latency for lower retention cost and can take 20-40% off this number if your access patterns suit it.
• Custom metrics: 150,000 metrics total. On Infra Pro (100/host included), that leaves ~100,000 overage; on Enterprise (200/host included), ~50,000 overage. At the historical $0.05/metric reference rate, that is $5,000/month (Pro) or $2,500/month (Enterprise). Datadog now directs to sales for current pricing — verify.
• APM trace ingestion: at this volume, trace overage adds $1,000-2,000/month.

Rough monthly total: $23,000-$30,000/month, or $280k-$360k/year, depending on Infrastructure tier and log SKU.

Grafana Cloud estimate (Pro tier):

• Platform fee: $19/month.
• Metrics: 500 hosts at ~150,000 active series total. After the 10,000 series free allowance, overage is 140,000 series at $6.50/1k = $910/month.
• Logs: 7,500 GB/month at the three-part rate (~$0.55/GB combined at default retention). After the 50 GB free allowance, ~7,450 GB overage = ~$4,100/month. Effective per-GB varies with retention configuration; tune Retain duration before assuming this number.
• Traces: $800-1,500/month after the included allowance.
• Add-ons (synthetics, OnCall, IRM) as needed: $200-500/month.

Rough monthly total: $6,000-$7,000/month, or $72k-$84k/year.

Self-hosted estimate:

• Infrastructure: dedicated EKS node pool for observability (~8-10 nodes), S3 storage for hot and cold log/trace tiers, an internal load balancer, a Redis/Memcached for the Loki/Mimir cache layer. Roughly $3,500-5,000/month.
• Engineering time: 30-40% of one platform engineer (~$6,000-8,000/month loaded).

Rough monthly total: $9,500-$13,000/month, or $114k-$156k/year.

At this tier, the math shifts. Grafana Cloud is the cheapest in cash terms by a wide margin. Self-hosting is now competitive with Grafana Cloud once you exclude labor, and the gap to Datadog has become large enough that the conversation is no longer "which UI do we prefer." Many mid-market platform teams at this tier run a hybrid: Grafana Cloud (or self-hosted) for logs and metrics, with a smaller Datadog footprint for APM on the services that need its depth. We have implemented this split at several engagements; it works as long as you have discipline about which services go where.

The hidden Datadog cost at this tier is custom metrics. We have seen teams add a single Prometheus exporter (Kafka exporter, Postgres exporter) and push their custom metric count up by 20,000 — at the historical $0.05/metric reference rate, a $1,000/month increment with no business decision attached. Even if the current overage rate is different, the shape of the surprise is the same.

Tier 3: ~2,000 hosts

Profile: 2,000 hosts, 800 GB/day of logs, 400 custom metrics per host, broad APM coverage, full distributed tracing on the production path with sampling.

Datadog estimate (list, before negotiated discount):

• APM: 2,000 x $31 = $62,000/month.
• Logs: 24,000 GB/month — ingest alone is $2,400; indexed retention on Standard Indexing pushes total log cost into the $15,000-22,000/month range depending on retention and event size. Flex Logs can compress this materially if access patterns suit it.
• Custom metrics: 800,000 metrics total. On Enterprise Infrastructure (200/host included), allowance is 400,000, overage 400,000. At the historical $0.05/metric reference rate, that is $20,000/month; Datadog now directs to sales for current rates and meaningful enterprise discounting is typical at this volume. Verify before locking the budget.
• APM traces and additional features: another $5,000-10,000/month.

List total: $100,000-$120,000/month, or $1.2M-$1.4M/year. With a negotiated enterprise discount (typically 20-35% at this volume), realistic landed cost is $800k-$1.1M/year. Specific custom-metric pricing has the largest range; that is the line item to negotiate.

Grafana Cloud estimate (Advanced/Enterprise tier, with commit):

• Metrics: 2,000 hosts x ~600,000 active series total. At list ($6.50/1k after the 10k free allowance), that is ~$3,830/month for series alone; negotiated commit pricing at this volume typically brings effective per-1k rate down. Expect $3,000-5,000/month all-in for metrics.
• Logs: 24,000 GB/month at negotiated rate (often well below the $0.55/GB combined list at this volume) = $7,500-10,000/month.
• Traces: $3,000-5,000/month.
• Platform / add-ons / users: $500-1,500/month.

Rough monthly total: $14,500-$22,000/month, or $175k-$265k/year.

Self-hosted estimate:

• Infrastructure: a dedicated observability cluster (~30-40 nodes), tiered S3 storage with lifecycle policies, internal load balancers, a serious caching layer, Kafka or similar for the log pipeline if you go that route. Roughly $25,000-40,000/month including storage and network.
• Engineering time: 1-1.5 full-time engineers ($25,000-37,500/month loaded).

Rough monthly total: $50,000-$77,500/month, or $600k-$930k/year.

At this tier, Grafana Cloud is usually the lowest total cost. This contradicts the conventional wisdom that "at scale you should self-host." The conventional wisdom is from a different era; Grafana Cloud's commit pricing at this volume is genuinely competitive with what a well-run self-hosted stack costs once labor is included. Self-hosting beats Grafana Cloud only when (a) you have specialized requirements that the SaaS does not meet — air-gapped environments, specific data residency, custom retention tiering — or (b) you already have a platform team with deep Prometheus / Mimir / Loki experience and the marginal engineering cost is genuinely zero.

Datadog at this tier is almost always more expensive than the alternatives by 2-4x. Teams stay because migration is expensive, training is significant, and the platform's depth on APM is real. None of those reasons are wrong. They are just expensive.

The hidden gotchas, by platform

Datadog. The line items that surprise teams the most: custom metrics (especially when a Prometheus exporter goes in without review — and remember the allowance lives on the Infrastructure tier, not APM); indexed log retention (the difference between 7-day and 30-day indexed retention on Standard Indexing is large; Flex Logs and Forwarding-only tiers carry different economics); and the per-host APM SKU specifically on Kubernetes, where a host is a node and a node running 40 pods costs the same as a node running 5 pods. That incentivizes node consolidation in ways that may or may not match your operational preference. (Note: this dynamic is specific to per-host APM SKUs; usage-based APM tiers behave differently.) Datadog publishes all of this; the surprise is not deception, it is compounding.

Grafana Cloud. Active series counts can grow non-linearly with cardinality. A single Kubernetes deployment with high-cardinality labels (pod name, container, instance) can produce tens of thousands of unique series; at $6.50 per 1,000 active series, that adds up quickly. The standard mitigation is recording rules and aggressive label dropping, but these require Prometheus / Mimir expertise. Log billing is a three-part rate (Process, Write, Retain) so retention configuration is a real cost lever — shortening Retain on noisy log streams is the highest-leverage tuning. Queries against ingested data have a usage component on some tiers; a curious engineer running broad log queries during an incident can move the bill.

Self-hosted. The honest cost is not the EKS bill, it is the on-call burden. A self-hosted Loki cluster with poorly tuned retention will fall over during the worst possible incident. Tempo at scale requires real attention to object storage tiering. Mimir at high cardinality requires careful resource planning. None of this is hard; all of it requires an engineer who has done it before. If you do not have that engineer, the savings on paper do not materialize in practice. We have rescued multiple self-hosted observability stacks that had become the source of more pages than the systems they were meant to observe.

When each option breaks down

Datadog stops making sense when: custom metrics, log indexing, or per-host APM counts push the annual spend above roughly $400k-$500k and the platform's depth is not load-bearing for your incident response. Below that ceiling, the productivity argument often wins. Above it, the conversation becomes "what could we do with $300k of saved spend."

Grafana Cloud stops making sense when: you have specialized data residency or air-gap requirements, or your cardinality has grown to the point where active series pricing crosses the self-hosted total cost. We have seen this happen at scale-up companies with metric-heavy ML workloads — not the typical mid-market profile, but worth watching.

Self-hosting stops making sense when: the team that was supposed to maintain it has churned, or the platform team's time has gotten reallocated to product-facing work. The hidden cost of self-hosting is fragility: if the one engineer who knew the stack leaves, the cost of bringing in someone new (consultant or hire) can wipe out a year of savings.

A 90-day decision framework

If you are looking at your observability bill and asking "should we move," here is the sequence we run with mid-market clients:

1. Days 1-15: baseline current cost and current usage. Pull the last 12 months of observability invoices. Pull current log GB/day, active series, custom metric count, host count, and trace volume. Separate cash cost from engineering time spent on the platform.
2. Days 15-45: model the alternatives. Use the published pricing pages to model each alternative against your current usage profile, not against your projected one. Include a sensitivity analysis for 1.5x and 2x growth. For Datadog, model both the Infra Pro and Enterprise custom-metric allowances, and the three log SKUs (Forwarding, Standard Indexing, Flex Logs). For Grafana Cloud, model with and without the included 10,000 series / 50 GB monthly allowances and vary the Retain duration.
3. Days 45-60: assess the migration cost honestly. Engineer-weeks for instrumentation changes, training, dashboard recreation, runbook updates, alert migration. We have seen migrations cost 6-12 engineer-weeks at 500 hosts and 20-40 engineer-weeks at 2,000 hosts.
4. Days 60-75: pilot. Run the alternative alongside production for a single team or service. Validate that incident response actually works in the new platform under real conditions.
5. Days 75-90: decide. A migration with a payback period over 18 months should be deferred. A payback under 9 months is usually worth doing.

The most important discipline in this sequence is honest accounting of engineering time. Self-hosting always looks cheaper in cash and always looks more expensive after labor. Get the labor number right before you decide.

For the broader budget conversation this fits into, see our FinOps savings guide and our FinOps framework for 50-500 person companies.

Where this framework breaks

This piece assumes a single-platform decision. In practice, larger mid-market environments split observability across multiple platforms — Datadog for APM on revenue-critical services, Grafana Cloud or self-hosted for logs and metrics, Honeycomb for distributed tracing on the products that need its depth. Hybrid is not a failure mode; it is often the lowest-total-cost answer. The risk with hybrid is operational complexity and runbook fragmentation. Decide deliberately, document the split, and revisit annually.

This piece also assumes you are not in a heavily regulated environment. If you are processing financial transactions, healthcare data, or operating under FedRAMP, the calculus shifts toward platforms with the right compliance posture. Datadog and Grafana Cloud both have strong compliance pages; verify the specific certifications you need before pricing dominates the decision.

If you would like help running the 90-day evaluation — particularly the engineering-time accounting and the migration cost estimate — our FinOps practice has run this exercise across observability stacks of every size in the mid-market. We will tell you when the answer is "stay where you are."

FAQ

Is Datadog always the most expensive option? At 500+ hosts with non-trivial logs and custom metrics, yes, almost always, by a factor of 2-4x against Grafana Cloud and self-hosted. Below 100 hosts the difference is smaller and the depth of Datadog's APM and UI is often worth the premium. The mistake is assuming the ratio at 100 hosts will hold at 1,000 hosts. It will not.

How much engineering time does self-hosting actually take? At 100 hosts, 10-15% of one platform engineer if the stack is well-tuned. At 500 hosts, 30-40%. At 2,000 hosts, 100-150% (one engineer plus burst help from a second). This assumes the team has prior Prometheus / Mimir / Loki experience. Without that experience, double the numbers and budget for two consultants on standby for the first six months.

What about New Relic? New Relic's user-based pricing is genuinely simpler and can be cheaper than Datadog at companies with smaller engineering teams and high data volume. At 100-300 hosts with 15-20 engineers, New Relic often comes in below Datadog. At 1,000+ hosts the ingest-based pricing component becomes the dominant cost line and the picture changes. Worth modeling. The Francisco Partners / TPG take-private (closed November 2023) has not produced material pricing disruption to date.

What about Honeycomb? Honeycomb is excellent for distributed-tracing-first observability and the pricing scales more predictably than Datadog at high trace volumes. We see it adopted most often at engineering-led organizations with a strong culture of observability-driven development. It is not a full replacement for logs and metrics infrastructure; teams usually pair it with Grafana Cloud or Datadog for those signals.

Should we worry about Splunk-Cisco? The Cisco acquisition closed in 2024. Pricing direction and product roadmap have been less aggressive than some expected. For greenfield mid-market deployments we rarely see Splunk as the lowest-total-cost answer; for environments already on Splunk for SIEM, expanding into observability there can be reasonable. Evaluate based on your specific contract terms, not the headline relationship change.

How often does observability pricing change? Vendor pricing pages change every 6-12 months at the published level, and contract terms can change quarterly through commit deals and discounts. The figures in this piece are published rates as of mid-2026 — verify directly. The structural pattern (the relative cost of Datadog vs Grafana Cloud vs self-hosted at each scale tier) is more stable than the specific numbers and has held through several pricing cycles.

Is there a "fourth option" we should consider? OpenTelemetry plus a vendor of your choice on the backend. OTel as the instrumentation layer means your application-side investment is portable — if you change backends, the agents and SDKs do not need to change. We recommend OTel as the instrumentation default regardless of which backend you pick. It is the single most useful insurance policy against future pricing surprises.