How to escape Datadog's billing model: comparing cost structures across observability platforms

Datadog’s bill scales with variables engineering leaders often cannot forecast precisely: telemetry volume and custom metric cardinality. The vendor-stated list price looks manageable, $15–$23 per infrastructure host and $31 per APM host under annual billing, but the per-GB and per-metric meters stacked on top turn every new service or environment, along with each Kubernetes label, into a billing event (Datadog pricing). Coinbase settled a bill of roughly $65 million for 2021, confirmed on Datadog’s Q1 2023 earnings call (The Pragmatic Engineer, earnings transcript).

That billing structure creates a tension the pricing page never states. Full visibility means collecting everything; usage-based billing punishes collecting everything, so teams sample traces and suppress other telemetry to protect the budget. Evaluating Datadog competitors on cost model, rather than feature checklists, is how you escape that trade.

This guide covers why teams leave Datadog, how its pricing breaks down mechanically, what to evaluate in an alternative, a comparison table of the top Datadog competitors, cost-model verdicts by competitor category, how OpenTelemetry reduces switching cost, what total cost of ownership includes, a use-case decision guide, and an FAQ.

Why engineering teams move away from Datadog

Billing unpredictability is one driver. Gartner’s July 2025 Magic Quadrant for Observability Platforms cautioned that Datadog has a “licensing model that might make it challenging for customers to negotiate contracts” and that “the cost of the product remains a concern among Gartner customers” (Network World). Gartner analysts separately reported that up to 84% of observability users struggle with monitoring costs and complexity (The New Stack).

Lock-in compounds billing unpredictability. The same Gartner report warned that Datadog’s “tightly integrated ecosystems can make the cost and complexity of integrating with non-Datadog tools a challenge for customers,” and a January 2025 Gartner telemetry pipeline report flagged the “lock-in risk of purchasing a telemetry pipeline from the same vendor as their main observability platform” (The New Stack). For a VP of Engineering, deep agent integration plus a proprietary query language means switching costs grow every quarter, which weakens renewal leverage exactly when the bill is growing.

Data residency creates a separate operational constraint. Datadog operates nine independent site regions and states plainly: “Each site is completely independent, and you cannot share data across sites” (Datadog docs). Its contracting FAQ adds that “Data may be accessed from any non-sanctioned country by your personnel and Datadog’s personnel as part of our follow-the-sun support model” (Datadog legal). TechTarget reported in June 2026 that Datadog introduced BYOC for telemetry, but the available evidence does not establish whether that deployment is equivalent to a fully sovereign one (TechTarget).

Having established why teams leave, the next question is how Datadog constructs the bill.

How Datadog’s pricing model works and where it breaks down

Datadog prices each capability as a separate meter, and the meters compound. Datadog states the following core list prices (Datadog pricing):

• Infrastructure monitoring: $15/host/month (Pro) or $23/host/month (Enterprise) under annual billing.
• APM: $31 per APM host per month under annual billing, on top of the infrastructure charge.
• Logs: $0.10 per GB ingested, plus $1.06–$2.50 per million indexed events per month depending on retention.
• Custom metrics: 100 indexed custom metrics included per Pro host; overages at $5 per 100 metrics per month.

The custom metrics meter is where high-cardinality environments break the model. Datadog counts each unique metric-name-and-tag-value combination as a custom metric, and DISTRIBUTION and HISTOGRAM metric types generate five billable custom metrics per unique tag combination by default (Datadog billing docs). Dynamic Kubernetes labels and pod names multiply the count. Request identifiers create the same risk when they land in a tag.

Wolt’s engineering team documented what that looks like in production. A single metric with an inadvertently submitted entity_id tag exploded to nearly 2 million unique time series, and Datadog’s integration auto-injected AWS metadata tags, which accounted for roughly 40% of total custom metric volume despite appearing in no dashboard or alert. Wolt published illustrative figures, rather than actual invoices, of about $457,500 per month without remediation versus about $123,500 with its trimming tooling (Wolt Engineering).

Pricing by tag combination turns a single unbounded tag into a billing risk across otherwise valid configurations. The Wolt incident shows the production consequence: one unbounded tag can create millions of billable series before a team notices. That is the specific risk an alternative’s cost model needs to remove, which brings us to the evaluation framework.

What to look for in a Datadog alternative

Six criteria separate a genuine fix from a repriced version of the same problem. Score every candidate against all six before comparing dollar figures.

• Pricing model type: Identify the billing unit: per GB, per event, per host, per node, per user, or consumption credits. Then ask which production variables move it. A unit tied to data volume or cardinality reproduces Datadog’s spike risk under a different name.
• OpenTelemetry support: OTLP ingestion as a first-class source means your instrumentation outlives the vendor. Proprietary agents rebuild the switching cost you are trying to escape.
• Self-hosting or BYOC: A self-hosted stack can eliminate vendor license and ingestion fees. BYOC changes the data-residency boundary but removes a vendor ingestion meter only when the contract does not retain one. Check the tier gate because vendors sometimes reserve these options for enterprise contracts.
• Data residency controls: Confirm the telemetry storage location and available regions. Then review personnel access across jurisdictions. Teams in regulated industries will ask before you do.
• APM depth: Distributed tracing, service maps, and code-level context vary widely. A cost model only matters if the tool can close your incidents.
• Cardinality handling: Ask what happens when a metric hits 200,000 unique tag combinations: a surcharge, a throttle, or a system failure. The answer predicts your worst month.

With the framework set, the next step is mapping the field against it.

Top Datadog competitors at a glance

The table below summarizes the cost model, deployment options, OpenTelemetry posture, and best-fit use case for each major alternative:

The table organizes the categories. Evaluating the cost-model mechanics provides the basis for each verdict.

How the top Datadog competitors compare on cost model

No competitor removes cost risk; each relocates it. Enterprise SaaS vendors keep usage meters running under new names, open-source stacks convert the invoice into engineering labor, specialized tools reprice the billing unit, and groundcover decouples the price from data volume. The sections below work through each group in the order the table lists them.

Enterprise SaaS: Dynatrace, New Relic, Splunk

Dynatrace bills through DPS, a consumption model that draws against a minimum annual commitment at vendor-stated rates: roughly $58/month for a full-stack-monitored 8 GiB host and $0.20/GiB for log ingest, plus separate retention and query charges. Dynatrace expires unused commitment at the anniversary date (Dynatrace rate card, pricing). On cost model, DPS reproduces Datadog’s forecasting problem with different meter names.

New Relic charges on two axes: a vendor-stated $0.40–$0.60/GB ingested beyond a perpetual 100 GB/month free tier, plus per-user seats from $49 for core users to $349 per full-platform user per month when billed annually, or $418.80/user/month on a pay-as-you-go basis (New Relic pricing). The seat model creates an access trade-off for organizations that want every engineer inside the observability tool during an incident. New Relic’s free tier reduces entry cost, but ingest and provisioned user counts remain billing variables.

Splunk Observability lists $15/host/month for infrastructure and $55/host/month for standalone APM, with bundles at $60 and $75 (Splunk pricing). Log analytics at scale runs through Splunk Cloud Platform, whose per-GB and workload rates remain unpublished and require a sales conversation (Splunk pricing FAQ). An unpublished log rate prevents teams from forecasting that part of the bill from public information.

Open-source and self-hosted: Grafana, Prometheus, SigNoz

Grafana offers two economies. Self-hosting the LGTM stack, which includes Loki for logs, Grafana for visualization, Tempo for traces, and Mimir for metrics, eliminates license and vendor ingestion fees; Grafana Cloud lists $19/month plus usage, including $6.50 per 1,000 active metric series at the first tier and $8 per user, with the Enterprise tier starting at a $25,000/year minimum (Grafana pricing). The active-series meter behaves like Datadog’s custom-metric meter in Kubernetes environments because every unique series affects usage.

Prometheus covers metrics only, and its official FAQ states: “Don’t use Prometheus for logs!” Its local TSDB is neither clustered nor replicated, so teams that need a complete observability stack must add and operate other components. The license removes a vendor subscription, while infrastructure and engineering labor remain part of total cost.

SigNoz is the OTel-native drop-in of the group. SigNoz states that its Cloud service charges $0.30/GB for logs and traces and $0.10 per million metric samples with a $49/month minimum, and the non-enterprise core uses an MIT license for self-hosting (SigNoz pricing, license). SigNoz’s own October 2025 comparison modeled $11,330/month versus $59,463/month on Datadog for a workload of 7,110 GB/month of logs, 21,400 GB/month of traces, and 15,000 custom metrics (SigNoz). Per-GB billing avoids cardinality surcharges, though the bill still scales with volume; the self-hosted path removes vendor ingestion cost and adds the operational burden every self-hosted stack carries.

Cloud-native and specialized: Elastic, IBM Instana, AppDynamics, CloudWatch

Elastic unifies observability with SIEM and XDR on the same Elasticsearch infrastructure and offers a self-host path. Elastic’s vendor-stated Serverless Observability rates start as low as $0.07/GB ingest on the Essentials tier, with hosted plans from $99/month (Elastic serverless pricing, hosted pricing). Teams still need workload-specific calculations because ingest, retention, and egress use separate billing dimensions.

IBM Instana bills per Managed Virtual Server: $20/MVS/month for Essentials or $75/MVS/month for Standard, with fair-use ingestion allowances of 50 GB and 325 GB per MVS, a 10-host minimum, and unlimited users (IBM pricing). The MVS unit is simpler than Datadog’s meter stack, but the tiers cover different scopes. Essentials excludes distributed tracing, synthetics, RUM, and AI observability, so teams that require those capabilities need the $75 Standard tier.

Splunk AppDynamics lists vendor-stated prices per vCPU: $6/month for infrastructure, $33/month with applications, and $50/month for premium with business analytics (Splunk pricing). Cisco closed its Splunk acquisition in March 2024, AppDynamics products now carry the Splunk name, and Splunk shipped a combined AppDynamics/Splunk agent in September 2025 (Cisco, Splunk blog). These consolidation changes add a roadmap consideration to the per-vCPU cost model.

CloudWatch looks inexpensive per unit and compounds across separate meters. AWS lists custom metrics from $0.30 per metric per month and log ingestion at $0.50/GB; AWS also charges for every GetMetricData API call and excludes those calls from the free tier (AWS pricing). SMG Swiss Marketplace Group found 65% of its CloudWatch bill came from GetMetricData calls and cut costs 78% by restricting scope; CloudFix documented a Lambda function costing $205/year in compute that generated over $10,000/year in log charges (SMG, CloudFix). Gartner notes CloudWatch is “designed and optimized for integration with AWS services,” with limited prebuilt cross-cloud ingestion and egress charges to assess carefully (AWSInsider). It fits single-cloud AWS estates that can accept those boundaries.

Cost-control-focused: Chronosphere, Honeycomb

Chronosphere approaches cost as a governance problem: Prometheus-compatible ingestion with tooling to shrink data before persistence. Chronosphere offers two contract-only models with no public dollar rates: a capacity model with fixed data-points-per-second and cardinality limits, or a consumption model that draws credits against persisted series and datapoints (capacity licensing, consumption licensing). Its savings evidence is vendor-published, including DoorDash’s stated $42.5M saved over three years (Chronosphere), and one Gartner Peer Insights reviewer called the billing model “complex and requires deep thinking to understand the trade-offs” (Gartner Peer Insights). Palo Alto Networks closed its $3.35 billion acquisition of Chronosphere in January 2026, and Forrester analyst Carlos Casanova predicted bundling will pressure pricing and roadmaps within 12–18 months (Palo Alto Networks, Forrester). The model suits high metric volumes when a dedicated team will manage persisted data.

Honeycomb inverts the cardinality problem. Honeycomb states that billing is per event at $3.00 per million on the Pro plan effective July 1, 2026, with 20 million free events monthly and unlimited seats on every plan (Honeycomb pricing, plan changes). Cardinality does not change the event price: “We charge the same for each event, whether it has two or 1500 attributes attached” (Honeycomb). Honeycomb throttles overages rather than adding a surcharge after a second consecutive month (usage docs). The model suits wide, high-dimension events, with the caveat that a 150-span trace is 150 billable events, so span volume is the meter to watch.

groundcover: comprehensive telemetry through eBPF and BYOC

groundcover’s architecture starts with comprehensive telemetry access. The eBPF sensor deploys as a single DaemonSet, one pod per node, and captures metrics, traces, logs, and Kubernetes events directly from the Linux kernel with zero application instrumentation. Coverage therefore does not depend on an SDK rollout.

BYOC, Bring Your Own Cloud, is the default at every tier including free. The data plane runs inside your VPC, with ClickHouse storing logs and traces alongside events and VictoriaMetrics storing metrics, while groundcover manages the control plane for UI and orchestration.

The architecture changes collection behavior before it changes the bill. Removing the volume penalty lets teams retain comprehensive telemetry without creating an incentive to sample traces, ration log ingestion, or leave staging unmonitored.

groundcover states that its flat rate applies per monitored Kubernetes node or Linux host: $30/host/month on Pro, $35 on Pro+/Enterprise, $50 for Enterprise On-Premises, with a free tier at $0. No meter tracks data volume. Log GB, trace spans, custom metric cardinality, and user count do not change the per-node unit price.

groundcover designed monthly-average billing to prevent short autoscaling spikes from creating disproportionate charges. The current packaging includes paid capability modules at every paid tier, while retention, SSO, RBAC, support, and deployment options vary by plan.

The architecture and flat per-node model replace separate meters for infrastructure, APM, log ingestion, indexing, and custom metrics. With the categories compared, the remaining question is how to keep whichever backend you choose replaceable.

How OpenTelemetry protects you from vendor lock-in

OpenTelemetry separates instrumentation from the backend. You instrument once with OTel SDKs, route telemetry through an OTel Collector, and switch vendors by changing exporter configuration instead of re-instrumenting applications. CNCF’s graduation announcement for the project in May 2026 stated that the standard allows “organizations to switch observability backends without re-instrumenting their entire codebase” (CNCF).

Teams have documented that switching effect in practice. Shaped AI already ran an OTel Collector, so moving to a new backend took “three lines of code or something, basically,” and the team completed the transition within days (SigNoz case study). LexisNexis migrated from Datadog to Grafana Cloud in four months and reported that it cut observability costs by more than 50% (Grafana blog). Gartner now describes OTel and eBPF-based instrumentation as having “lowered barriers to switching observability providers” to the point where OTel support is “a baseline requirement rather than a differentiator” (Network World).

Two caveats keep the protection honest. An Omdia analyst noted in June 2026 that Datadog’s proprietary OTel distribution preserves lock-in because “all the good stuff is only available when you run it with the Datadog agent” (TechTarget). OTel also covers instrumentation only: one financial company’s Datadog-to-Grafana migration took roughly a year overall because the team had to migrate backend assets and policies separately (Grafana case study).

groundcover treats OTel as a first-class source alongside its own collection. It ingests OTLP with eBPF’s kernel-level eBPF signals, so existing OTel instrumentation carries over intact and coexists with eBPF-captured data in the same interface. Your instrumentation stays portable in both directions, which is the property that keeps renewal negotiations honest.

Total cost of ownership: comparing the full bill

Observability costs fall into externally billed platforms and self-hosting, while externally billed platforms use different units. Usage-based SaaS ties the invoice to production variables such as log volume, series count, and cardinality, so the bill becomes a lagging indicator of engineering decisions nobody priced. Self-hosting moves part of the bill into payroll: DuckDuckGo SRE Colin Douch told QCon London 2026 that self-hosting observability requires “at least an extra 2–3 full-time engineers and significant money” (InfoQ). Flat per-node pricing ties the vendor bill to node count, which a capacity plan already forecasts.

Published models dispute the self-hosting break-even point. JSLet’s authors calculate that self-hosted LGTM becomes less expensive than Grafana Cloud from about 200 hosts up (JSLet), while OptiVulnix’s authors weight labor differently and calculate that Grafana Cloud remains less expensive at 2,000 hosts (OptiVulnix). Both modeling teams calculate that self-hosting below roughly 100 hosts costs more once they include labor.

Now map the structures onto a concrete scaling scenario: 80 nodes growing to 300 over a year. On groundcover’s Pro+ tier at $35/node, that is $2,800/month rising to $10,500/month, a straight line Finance can put in a budget. On usage-based models, host and APM-host charges rise with the 3.75x node growth. Log volume and unique tag combinations can also increase, but teams must model each variable separately because each follows its own billing curve. One Reddit r/sysadmin account describes the tail risk: a single developer’s custom metric keyed on unique URLs produced a $30K monthly overage “and there was no warning at all until the account manager let us know it was coming” (r/sysadmin).

Non-production environments expose the same divergence. One Hacker News practitioner reported roughly $5K/month on Datadog for 10 low-traffic QA environments, one per team (Hacker News), which is why staging and dev so often go unobserved under usage pricing. Under a per-node model those environments cost their node count and nothing more; BigBasket reported a 50% reduction in observability spend on groundcover while expanding coverage across production, development, and testing. Flat per-node pricing explains that outcome because added telemetry and environments did not change the unit price.

Choosing the right Datadog alternative for your use case

Match the tool to the constraint that drives your evaluation. If the constraint is cost reduction at small scale, SigNoz Cloud or self-hosted LGTM fits, provided you accept volume-based billing or the operational load. If the constraint is high-cardinality debugging, Honeycomb’s per-event model removes the cardinality penalty. If the constraint is metrics governance at extreme volume with a dedicated team, Chronosphere fits. If the constraint is AI and LLM workloads, groundcover’s AI Observability combines eBPF auto-detection of model calls with OTel instrumentation for agent-level traces, including token cost and latency at span level, with an evals capability in development.

Choose groundcover if:

• You run Kubernetes and want comprehensive coverage without an instrumentation sprint: The eBPF sensor deploys as one DaemonSet and provides full-cluster visibility within hours, with no per-service SDKs, on EKS, AKS, and GKE with Kubernetes 1.21+ and Linux kernel 4.16+.
• Data sovereignty is a requirement, not a preference: BYOC keeps the data plane, including ClickHouse and VictoriaMetrics, inside your VPC at every tier, with on-premises and air-gapped options for regulated environments.
• You need a cost model Finance can forecast: Flat per-node pricing means node count is the only billing variable, and monthly-average billing absorbs short autoscaling spikes.
• You want the whole organization inside the tool: There are no per-user fees; Afida expanded from 10 to roughly 100 users with no change in cost because pricing is per node and user count never touches the bill.

Choose another tool if:

• You want managed SaaS with zero infrastructure in your account: Datadog, Dynatrace, New Relic, and Splunk Cloud run everything on the vendor’s side; BYOC puts a data plane in your VPC, managed by groundcover but resident with you.
• Your estate is AWS-only and shallow observability suffices: CloudWatch’s native integration covers single-cloud AWS workloads without adding a vendor.
• You have deep existing enterprise APM investment: Dynatrace’s Davis AI, Instana’s IBM distribution and mainframe support, or Splunk’s query ecosystem can justify staying inside those environments.
• Your workloads sit outside Kubernetes and Linux: groundcover’s current product scope excludes AWS Fargate and Docker Desktop, so evaluate alternatives against the operating systems and deployment models in your estate.

If you want to validate the architecture on your own cluster, the free plan includes BYOC and requires no credit card. Deploy eBPF on one cluster and evaluate full-cluster visibility within hours.