What if the biggest line item in your observability budget has almost nothing to do with which vendor you picked? Teams spend weeks comparing per-host rates and ingest fees, then discover that a single tag added to a metric name multiplied their bill by six. The bill was never really about the price list. It was about architecture.
That gap between list price and real cost is the whole story heading into 2027. Five platforms dominate the conversation, and each one bills from a different mental model. Understanding those models, and the engineering choices that feed them, matters more than any spreadsheet comparison.
Why the Price List Is the Least Useful Document You’ll Read
Public pricing pages for observability vendors get revised constantly, and enterprise discounts are never public. Any comparison built on sticker prices is stale within a quarter. What stays stable is the underlying mechanics: what each vendor counts, when it counts it, and how your instrumentation decisions change the count.
The dominant cost levers are the same everywhere. Cardinality (the number of unique metric and tag combinations), log volume, trace sampling rate, and retention period drive spend across all five platforms. The same workload can differ by an order of magnitude depending on whether you ingest and index everything or filter and aggregate before data reaches a paid backend.
That is why the useful question in 2027 is not “who is cheaper” but “which billing model punishes the architecture we actually run.” A team with exploding tag cardinality will suffer on one platform and shrug on another. A team with modest metrics but heavy log volume faces the reverse.
The Five Billing Models, Stripped to Their Logic

Each vendor organizes billing around a different unit. Here is the shape of each model, without the dollar figures that will be outdated by the time you read this.
| Platform | Primary billing unit | What your architecture controls |
|---|---|---|
| Datadog | Per host, plus usage modules | Custom metric and tag cardinality, log indexing volume, APM hosts |
| New Relic | Per user seat, plus data ingest | Total GB ingested, number of full platform users |
| Grafana | Usage-based cloud, or self-hosted infrastructure | Metric series, log GB, traces, users; self-hosting trades license cost for ops cost |
| Dynatrace | Consumption units (DPS) across the platform | How much data lands in the Grail data lakehouse and how it is queried |
| Elastic | Resource-based self-managed tiers, consumption on cloud | RAM and CPU sizing, deployment type, feature tier |
The pattern is clear once you lay it out. Datadog and New Relic bill closest to the instrumentation surface. Grafana and Elastic push cost toward infrastructure and operations. Dynatrace bills by consumption across a unified platform. None of these is inherently better. They reward different engineering habits.
Datadog: Host-Based Billing With a Cardinality Trap
Datadog’s infrastructure monitoring is priced per host per month, with annual and on-demand tiers. APM, logs, and custom metrics are billed separately by volume. Custom metrics are billed per hundred metrics, and the documentation explains how metric names and tags are counted. This is where the trap lives.
A metric name combined with a tag creates a billable time series. Add a `user_id` or `request_id` tag and a single metric can become thousands of billable series overnight. It is one of the most common and most expensive mistakes in the field. The fix is architectural, not commercial: enforce tag hygiene at the instrumentation layer, drop high-cardinality tags before they reach the backend, and treat every new tag as a budget decision.
Datadog’s model rewards teams that curate aggressively. If your platform team can govern what gets emitted, per-host pricing is predictable. If application teams emit freely, the bill becomes a lottery. For a deeper look at how billing philosophy shapes platform choice, the comparison of Grafana and Datadog architecture decisions is worth reading alongside this one.
New Relic: Seats Plus Ingest Changes Who Pays
New Relic repackaged around 2020 into a per-user plus per-GB-ingest model, with a free tier that has included 100 GB per month and one free full user. The architectural consequence is unusual: cost now scales with people as well as data.
That flips an old assumption. On host-based platforms, adding engineers costs nothing extra. On seat-based platforms, broad access has a price, which pushes teams toward shared dashboards, service accounts, and careful user-type management. The ingest side behaves like everyone else’s: logs and traces dominate, and sampling is your main lever.
The practical guidance here is to map user types deliberately. Full platform users should be people who genuinely build and investigate. Everyone else, from executives checking dashboards to on-call engineers glancing at alerts, can often work through limited or shared access. Teams that skip this mapping are frequently surprised that their seat count grew faster than their data volume.
Grafana: You Pay in Infrastructure and Attention
Grafana splits into two very different products. Grafana OSS is open source under AGPLv3, and Grafana Cloud is a separate usage-based offering priced on metric series, log GB, traces, and users. Self-hosting shifts cost from licensing to infrastructure and operations, which is a real trade, not a free lunch.
The hidden cost of self-hosted Grafana is people. Someone owns upgrades, storage scaling, high availability, and the long-tail debugging when a data source misbehaves. Small teams often underestimate this. Larger platform teams with existing Kubernetes expertise usually find it manageable and appreciate the control.
Grafana’s architectural strength is that it sits on top of many backends rather than owning your data. That makes it a natural front end for a multi-backend strategy, and it pairs well with OpenTelemetry pipelines that route data to different stores by type. If you are weighing self-hosted infrastructure decisions more broadly, the trade-offs in Arch Linux versus Ubuntu architecture decisions follow a similar logic: control versus convenience, with operational maturity as the deciding factor.
Dynatrace: Consumption Across a Data Lakehouse
Dynatrace moved to a consumption model built around its Grail data lakehouse and the Dynatrace Platform Subscription, which bills in consumption units across observability, security, and application security. Older host-unit SKUs have been progressively replaced, and the details continue to evolve.
The architectural implication is that cost follows queries and retention as much as ingestion. A lakehouse-style platform can hold more data affordably, but heavy ad-hoc querying and long retention still consume units. Teams migrating from host-based models sometimes assume the new model is automatically cheaper and are surprised when broad, always-on dashboards and long lookback windows drive consumption.
The discipline that works: tier your data. Keep high-fidelity data short-term, downsample aggressively for long-term trends, and audit dashboards that refresh constantly against large datasets.
Elastic: Resource-Based Tiers and Sizing Discipline
Elastic’s self-managed licensing is tiered by feature, from a free Basic tier up through Gold, Platinum, and Enterprise, while Elastic Cloud bills by resource and deployment type. Cost therefore tracks cluster sizing: RAM, CPU, and storage.
This makes Elastic the most sensitive of the five to capacity planning. Over-provisioned clusters waste money quietly. Under-provisioned clusters fail loudly. The teams that do well here treat index lifecycle management as a first-class engineering concern: hot-warm-cold tiering, rollover policies, and shard sizing reviews on a schedule rather than after an incident.
Elastic is often already present for search or logging, which changes the calculus. Adding observability to an existing cluster can be cheaper than a new vendor, provided the cluster has headroom and the team understands its shard economics.
OpenTelemetry Is the Real Cost-Control Layer
All five vendors support OpenTelemetry ingestion to varying degrees, and that support matured substantially between 2022 and 2024. OTel is a portability hedge. It is also where cost gets decided.
A collector pipeline lets you filter, sample, aggregate, and route before data reaches any paid backend. Drop debug logs at the edge. Sample traces at 10 percent for high-volume services and 100 percent for the ones that break. Aggregate metrics so cardinality never explodes. Teams that build this layer first negotiate from strength, because switching vendors becomes a configuration change rather than a migration project.
The same principle applies across the stack. When teams evaluate Bun versus Node.js architecture decisions, the winning argument is rarely raw benchmark speed; it is how well the choice fits the operational pipeline around it. Observability works identically. The pipeline is the product.
Common Mistakes That Show Up on Every Bill
Experience across these platforms surfaces a repeating list of expensive habits. None of them are vendor-specific, and all of them are fixable.
- Tagging with unbounded values. User IDs, request IDs, and timestamps in tags are the single fastest way to multiply a bill on any cardinality-sensitive platform.
- Indexing everything. Ingesting all logs is fine; indexing all logs is not. Route verbose logs to cheaper storage and index only what you search.
- Sampling nothing. Full-fidelity traces on high-traffic services are rarely worth the cost. Tail-based sampling keeps the interesting traces.
- Skipping retention tiers. Most teams keep 30 days of hot data when they need 7, and keep nothing for a year when they need trend lines.
- Buying before instrumenting. Signing a contract before the OTel pipeline exists means you are guessing at volume. Instrument first, measure for a month, then negotiate.
- Ignoring user types. Seat-based models punish broad access; host-based models punish sprawl. Know which one you are on.
Matching the Model to Your Team
The right choice in 2027 depends less on the vendor and more on the shape of your organization.
| If your situation is… | The model that tends to fit |
|---|---|
| Strong platform team, heavy Kubernetes, wants control | Self-hosted Grafana with OTel routing |
| Many engineers investigating incidents daily | Host-based billing, where seats are free |
| Small team, wants managed everything | Consumption or ingest-based cloud |
| Elastic already running for search | Extend the existing cluster with lifecycle discipline |
| Regulated environment needing unified security and observability | Consumption across a single platform |
A useful exercise: model your actual monthly volume against two or three of these models before talking to sales. Most teams discover their current spend is driven by two or three specific decisions, not by the vendor’s rate card. Fixing those decisions often saves more than switching vendors would. The same logic shows up in AWS versus Azure versus GCP GPU cloud pricing architecture decisions, where workload shape beats headline rates every time.
Conclusion
The observability pricing conversation in 2027 is really an architecture conversation wearing a finance hat. Datadog bills the instrumentation surface, New Relic bills seats and ingest, Grafana bills infrastructure and attention, Dynatrace bills consumption across a lakehouse, and Elastic bills cluster resources. Each model rewards a different discipline.
The teams that win are not the ones that found the cheapest rate card. They are the ones that built an OpenTelemetry pipeline, governed tag cardinality, tiered retention, sampled traces intelligently, and matched the billing model to how their people actually work. Do that first, and the vendor comparison becomes a much shorter and much less stressful document. Verify any pricing figures against current vendor documentation before signing, because the numbers move and the architecture does not.
Frequently Asked Questions
Which observability platform is cheapest in 2027?
There is no universal answer, because cost depends on workload shape. A team with low cardinality and high log volume will find different platforms cheapest than a team with the reverse. Model your actual volume against each billing model before comparing quotes, and remember that enterprise discounts are never public.
What is the biggest hidden cost in Datadog pricing?
Custom metric cardinality. Datadog bills custom metrics per hundred metrics, and tag combinations multiply the billable count. A single unbounded tag such as a user ID can turn one metric into thousands of billable series. Enforce tag hygiene at the instrumentation layer to keep this predictable.
Does self-hosting Grafana actually save money?
Sometimes, but not automatically. Self-hosting removes per-seat and usage licensing but adds infrastructure, upgrades, storage scaling, and on-call responsibility. Teams with existing platform engineering capacity usually come out ahead. Small teams often find the operational cost exceeds the license savings.
How does OpenTelemetry reduce observability costs?
OpenTelemetry collectors let you filter, sample, aggregate, and route telemetry before it reaches a paid backend. That means dropping debug logs at the edge, sampling high-volume traces, and preventing cardinality explosions. It also reduces lock-in, since switching backends becomes a configuration change rather than a migration.
Why did New Relic’s seat-based model change how teams manage access?
Because cost now scales with people as well as data. On host-based platforms, adding engineers costs nothing extra. On seat-based platforms, broad access has a price, which pushes teams toward shared dashboards, service accounts, and deliberate user-type mapping so that only people who build and investigate hold full platform access.
What should teams do before signing an observability contract?
Instrument first. Build the OpenTelemetry pipeline, run it for at least a month, and measure real volume, cardinality, and retention needs. Then model that measured volume against two or three billing models. Signing before instrumenting means guessing at volume, and guesses in this market tend to be expensive.


