Datadog vs New Relic vs Dynatrace (2026): Enterprise APM Pricing Compared

Quick Answer: Which Enterprise APM Wins in 2026

For a 100-service, 200-host production estate, Datadog still has the deepest integration catalog and the most polished UX, but its per-host plus per-custom-metric billing model pushes real invoices into the $18-45K/month range once logs, RUM, and SIEM add-ons land. New Relic's flat per-GB-ingested pricing (post the 2022 model change) lands the same estate in the $8-22K/month range with far more predictable bills — at the cost of a weaker integration catalog and a UI that still feels like a product built by five acquired companies. Dynatrace is the most expensive headline number (DPS "Davis Points" licensing typically clears $25-60K/month for this size) but its OneAgent auto-instrumentation and Davis AI genuinely cut MTTR at large estates. Pick Datadog for breadth and DX, New Relic for predictable ingestion-based bills, Dynatrace for AI-first ops at 500+ services.

Last updated: April 2026 — verified pricing tiers, DPS calculator, New Relic Data Plus add-on, and the Datadog flex logs + APM matrix against each vendor's public docs.

Hero Comparison: Datadog vs New Relic vs Dynatrace at a Glance

Platform	Pricing Model	Starting Price	Free Tier	Best For	Key Differentiator
Datadog	Per-host + per-custom-metric + per-GB logs	APM Pro $31/host/mo	14-day trial, 5 hosts free infra	Breadth of integrations, polished UX	700+ integrations, best dashboarding
New Relic	Per-GB ingested + per-user seat	Standard $0.30/GB + $99/core user/mo	100 GB/mo + 1 full user free forever	Predictable bills, OTel-first shops	Flat ingestion pricing, no host caps
Dynatrace	DPS (Davis Points System) consumption units	$0.04-0.08 per DPS + host-hour	15-day trial, no perpetual free tier	Enterprise AI-driven RCA at scale	OneAgent auto-instrumentation + Davis AI

Affiliate disclosure: New Relic has a partner program we participate in. Datadog and Dynatrace are enterprise-sales-direct; we link to their official pages without affiliate tracking. When we reference open-source alternatives like Grafana Cloud or SigNoz, those are non-monetized.

How Enterprise APM Pricing Actually Works

APM pricing in 2026 splits along three philosophies, and understanding the split is worth more than any line-item breakdown. Datadog bills by the thing you own — hosts, containers, custom metrics, log events. New Relic bills by the data you send — gigabytes ingested, users with query access. Dynatrace bills by a synthetic unit (Davis Points) that abstracts hosts, spans, logs, and memory into one meter. Each model has a failure mode that blows up bills unpredictably: Datadog's is custom-metric cardinality, New Relic's is runaway log ingestion, Dynatrace's is the opacity of DPS consumption until you're already over-committed.

I've run procurement against all three in the last 18 months, and the pattern is consistent. Sticker price means nothing — what matters is the 90-day bill shock after engineers enable the features sales promised. The advanced patterns — cost-governance policies, ingestion quotas, OTel sampling pipelines — are in a follow-up I send to the newsletter.

Pricing Breakdown: 100-Service, 200-Host Scenario

Here's what a realistic mid-enterprise observability stack actually costs across all three vendors in Q2 2026. The scenario: 200 Linux hosts, 100 microservices, 2,000 containers, 500 GB/day of application logs, 50K custom metrics (moderate cardinality), 10 synthetic tests, 2M RUM sessions/month. All figures are list price before enterprise discounts (typically 20-35% at this scale, 40-55% for multi-year commits).

Component	Datadog	New Relic	Dynatrace
Infrastructure monitoring	$3,000/mo (200 hosts × $15)	Included in ingest	$8,640/mo (200 × $0.04 × 720 host-hours + DPS)
APM (per-host)	$6,200/mo (200 hosts × $31)	Included in ingest	Included in DPS
Log management (500 GB/day = 15 TB/mo)	$4,050/mo (0.10/GB ingest + $2.55/M events)	$4,500/mo (15,000 × $0.30)	$6,000-9,000/mo (DPS consumption)
Custom metrics (50K)	$4,000/mo ($0.05 × 50K on-demand)	Included in ingest	Included in DPS
RUM (2M sessions)	$3,000/mo ($1.50 per 1K sessions)	$1,200/mo (ingest-based)	$4,800/mo (DPS)
Synthetics (10 tests, 1-min freq)	$600/mo ($5 per 10K runs)	$0 (Free in Standard)	$400/mo (DPS)
User seats (15 engineers)	Included	$1,485/mo (15 × $99 core user)	Included (role-based)
Approx monthly list total	~$20,850	~$7,185	~$19,840-22,840
Annual list (before discount)	~$250K	~$86K	~$238-274K
Typical enterprise-discounted annual	$175-200K	$60-72K	$170-220K

Watch out: Datadog's custom metrics pricing is the single most expensive trap in observability. Every unique metric_name + tag_key_value combination counts as one custom metric. A single histogram metric tagged with user_id, endpoint, and status_code can cascade to 500K+ custom metrics in days. At $0.05/metric on-demand that is $25K/month. Cardinality audits before deploy are non-negotiable — and they apply to what we cover in Kubernetes resource requests and limits too, since pod labels frequently become metric tags.

Datadog: Breadth and Polish at a Premium

Datadog remains the reference product for unified observability. The integration catalog is genuinely unmatched — over 700 prebuilt integrations, and the ones I've touched in production (Kafka, RDS, Kubernetes, AWS Lambda) work the way the docs describe on the first try. The dashboarding is the cleanest of the three, and the Watchdog AI anomaly detection has actually caught regressions my static alerts missed — notably a gradual p95 drift on a payment service in late 2025 that Watchdog flagged four hours before customers complained.

The weakness is the pricing model. Per-host plus per-custom-metric billing compounds in ways finance teams hate. I've watched a startup's Datadog bill climb from $3K to $28K/month over six quarters without any change in infrastructure — just engineers adding instrumentation. The log management product uses a two-axis meter (ingestion and indexing) that makes cost attribution painful. Flex Logs (introduced mid-2024) helps by letting you archive first and rehydrate on demand, but most teams never configure it correctly.

AI-assisted RCA: Watchdog is genuinely useful for anomaly detection on a handful of KPIs; it is less useful for root-cause analysis across a distributed trace. The 2025 Bits AI assistant (chat-based incident triage) is early and hallucinates on complex topologies. For broader context on monitoring tool selection, the best monitoring tools breakdown covers the full landscape including open-source alternatives.

When Datadog wins: Series B-D SaaS companies with under 300 services, where engineer time saved on integration setup clearly exceeds the licensing delta. Also: teams already embedded in Datadog Logs and Datadog Security Monitoring, where switching cost dwarfs savings.

Honest weakness: The billing model punishes growth. OpenTelemetry support is technically complete (OTLP ingest since 2023) but internal translations still lose fidelity on some span attributes — the full picture is in OpenTelemetry vs Datadog.

New Relic: Predictable Ingestion-Based Pricing

New Relic changed its pricing model in July 2022, moving from per-host licensing to a flat per-GB-ingested meter plus per-user seats. That pivot is still the most honest simplification the observability industry has made this decade. You pay $0.30/GB ingested on Standard ($0.50/GB on Data Plus, which adds 90-day retention and HIPAA), and you pay per user — $0.99/mo for a basic user, $49/mo for a core user, $99/mo for a full platform user. That's it. Hosts, containers, APM, metrics, traces, and synthetics all fold into the ingestion meter.

The forever-free tier is serious: 100 GB/month ingest plus one full user, no credit card. For a small startup or a bootstrapped SaaS, this is enough to run a production stack. I've seeded three startups on the free tier in the last year; only one outgrew it within 18 months.

AI-assisted RCA: Applied Intelligence (formerly Proactive Detection) is competent but unremarkable. The 2025 New Relic AI assistant (a GPT-4-powered query builder) is useful for translating natural-language questions to NRQL but stops short of incident-scale RCA. Distributed tracing quality is on par with what OpenTelemetry gives you natively, which is not a coincidence — New Relic's agents emit OTLP.

When New Relic wins: Any team that wants predictable bills. Any OTel-first shop. Any team with heavy log volume where Datadog's indexing costs would be prohibitive. Also: engineering orgs that already think in terms of data ingestion quotas (they typically already run Prometheus + Grafana and understand cardinality economics).

Honest weakness: The UI is still a Frankenstein of acquired products (APM from 2008, Infrastructure from CloudFlare-era, Logs from a 2020 acquisition). Dashboarding is functional but visibly dated. The integration catalog is maybe 30% of Datadog's. If you need Cisco ACI monitoring or a native NetApp integration, New Relic will make you write it.

Dynatrace: DPS Licensing and AI-First Operations

Dynatrace is the most architecturally distinct of the three. OneAgent is a single binary that auto-instruments applications, containers, databases, and OS-level processes — no SDK imports, no manual spans, no Collector pipeline. Install the agent, Davis AI builds a topology graph, and within an hour you have full distributed traces, dependency mapping, and anomaly baselines. I've installed OneAgent on greenfield Kubernetes clusters and had actionable alerts within 30 minutes of first deploy.

Pricing is where Dynatrace loses people. The Davis Points System (DPS) introduced in late 2023 replaced separate host/log/span SKUs with a consumption model. One DPS costs roughly $0.04-0.08 depending on commit level, and every product feature — host monitoring, log analytics, application security, Grail queries, Davis AI computations — burns DPS at published rates. The upside is a single meter. The downside is that forecasting consumption requires a Dynatrace SE to model, and the model changes every time you enable a feature.

AI-assisted RCA: This is Dynatrace's category-defining strength. Davis AI does deterministic causation analysis on the topology graph — when a database connection pool saturates, Davis surfaces the service that caused it, the deploy that introduced the regression, and the log lines that correlate. It is genuinely better than Watchdog or Applied Intelligence for multi-service incidents. For teams drowning in alert fatigue, see alerting without burnout first.

When Dynatrace wins: Enterprises with 500+ services, heterogeneous tech stacks (Java, .NET, mainframe, SAP), and a genuine MTTR problem where Davis AI pays for itself in incident time saved. Regulated industries (banks, healthcare) where the security posture of OneAgent and Grail's immutable log store matters. Teams that value zero-touch instrumentation over OpenTelemetry portability.

Honest weakness: OneAgent is a black box. When it breaks, debugging requires Dynatrace support. OTel adoption is partial — Dynatrace accepts OTLP but OneAgent's data model doesn't fully match it, and hybrid pipelines are awkward. And DPS opacity is a real procurement problem: I've seen estimated vs actual annual spend diverge by 40% in year two.

Feature Comparison: AI, Auto-Instrumentation, and OTel Support

Capability	Datadog	New Relic	Dynatrace
AI-assisted RCA	Watchdog (anomaly detection), Bits AI assistant (chat triage)	Applied Intelligence + AI query assistant (NRQL)	Davis AI (causation graph, deterministic RCA)
Auto-instrumentation breadth	APM libraries for 12 languages, manual SDK imports	APM agents for 9 languages, OTel-first stance	OneAgent single-binary, 50+ tech stacks auto-discovered
OpenTelemetry support	OTLP ingest, internal translation lossy on some attributes	Full native OTLP, no agent required	OTLP ingest accepted, hybrid with OneAgent is awkward
Log ingestion billing	Per-GB ingest + per-event index (two-axis)	Per-GB ingest (flat)	DPS consumption (variable)
Custom metric cardinality limit	Unlimited (paid per metric)	Unlimited (no separate meter)	Unlimited (counts against DPS)
SIEM / Security product	Cloud SIEM (extra SKU, ~$0.20/GB)	Vulnerability Management (bundled from 2024)	Application Security (DPS-consumed)
Deep infra (eBPF, kernel)	Via Universal Service Monitoring add-on	Pixie (acquired 2020, OSS eBPF agent)	OneAgent kernel module (deepest)
Kubernetes native	Helm chart, DaemonSet agent	Helm chart + Pixie eBPF	OneAgent Operator, sidecar-free

flowchart LR
  A[Your Services] -->|OTLP / agent SDK| B{Instrumentation}
  B -->|Datadog Agent| C[Datadog SaaS]
  B -->|New Relic Agent / OTLP| D[New Relic Grail-lite]
  B -->|OneAgent auto| E[Dynatrace Grail + Davis AI]
  C --> F[Bills per host + metric + GB]
  D --> G[Bills per GB + user seat]
  E --> H[Bills per DPS consumption unit]

Hidden Cost Multipliers to Watch

The sticker-price comparison above is the easy part. The following cost vectors are where bills go sideways — regardless of vendor. For a deeper primer on each pillar, observability: logs, metrics, traces explained is the foundation.

• APM retention: 15 months default on Datadog, 8 days on New Relic Standard (90 on Data Plus), 35 days on Dynatrace Grail. Extended retention silently adds 20-30% to APM cost — audit before signing.
• High-cardinality metrics: Any unbounded label (user_id, trace_id promoted to tag) explodes Datadog cost and Dynatrace DPS consumption. New Relic dodges it on custom metrics but not on log ingestion.
• Containers as hosts: Datadog counts containers above ~20/host as additional billable units. Dense Kubernetes deploys can 2-3x your billable host count overnight.
• RUM session volume: All three bill per session. A marketing campaign that triples MAUs triples RUM bills for 30 days after.
• Synthetic frequency: 1-minute synthetics from 5 regions = 14,400 runs/day = $2K+/month on Datadog list. Drop to 5-minute frequency and cut 80% with negligible detection-latency impact.
• Profiling: Separate SKU on Datadog (+$2/host), bundled on New Relic, DPS-consumed on Dynatrace.

Per-Engineer TCO at 10, 50, and 200 Services

List-price TCO modeled across three team sizes, assuming moderate instrumentation depth and realistic engineer-to-service ratios. These numbers are before enterprise discounts, which typically cut 25-50% at the 200-service tier.

Scale	Datadog /mo	New Relic /mo	Dynatrace /mo	OSS Alternative
10-service startup (20 hosts, 2 engineers)	$900-1,400	$0-400 (free tier + overage)	$2,000-3,500	Grafana Cloud free / SigNoz self-hosted ~$150 infra
50-service mid-stage (100 hosts, 15 engineers)	$8,000-14,000	$3,500-6,500	$11,000-18,000	Grafana Cloud Pro ~$2,500 / SigNoz Cloud ~$3,000
200-service enterprise (500 hosts, 60 engineers)	$45,000-80,000	$18,000-35,000	$50,000-90,000	Grafana Cloud Advanced ~$12,000 + OTel Collector ops

At the enterprise tier, the gap between New Relic and Datadog funds an SRE salary. The gap between OSS and any vendor funds two. The catch with OSS, of course, is that you need engineering capacity to operate the stack. For log-specific trade-offs, centralized log management across Loki, ELK, and CloudWatch has the detail.

Migration Off Datadog: Cutting Costs 50-70%

The most common migration I see in 2026 is Datadog to a hybrid (Datadog for a subset of services, New Relic or OSS for the rest). A full cutover to OSS is rarer because the dashboarding and alerting rebuild is genuinely painful. Here is the playbook that works.

Pro tip: Phase the migration by telemetry type, not by service. Move logs first (highest cost, lowest dashboard complexity), then custom metrics (cardinality audit forces a rewrite anyway), then traces (hardest, most tooling dependencies). The whole cut takes 4-6 weeks for 10 services and 4-6 months for 200.

1. Audit Datadog spend by SKU. Pull the last 6 months of billing from the Admin > Plan & Usage page. Usually logs are 40-60% of the bill, custom metrics 10-25%, APM hosts 15-30%. This ratio tells you what to migrate first.
2. Run OTel Collector alongside the Datadog Agent. Both can coexist on the same host. Configure the Collector to ingest from dd-trace via OTLP receiver and dual-write to Datadog plus the new destination. Verify parity for 2-4 weeks.
3. Move logs first. New Relic's ingest cost is typically 40-60% lower than Datadog's at comparable volume. Cut indexing at Datadog once logs are flowing to New Relic and you've rebuilt the top 10 dashboards.
4. Audit custom metric cardinality. Before you migrate, fix the cardinality bomb — 80% of custom metric cost is usually in 5-10 poorly-tagged series. This cuts cost on both platforms.
5. Rebuild SLOs and alerts last. Alert-rule parity is the hardest part. For the philosophy, see SLOs, SLAs, and error budgets — the math doesn't change, only the query syntax.
6. Keep Datadog for one thing. I have not seen a clean full cutover. Usually Datadog keeps Security Monitoring or RUM. Plan for a partial-migration end state and negotiate a reduced commit.

Decision Matrix: Which APM Should You Pick

• Pick Datadog if: You're a Series B-D SaaS with under 300 services, your engineers value DX over procurement simplicity, you already use Datadog Logs and Security, and you're willing to invest in cost governance (cardinality audits, flex logs, retention tuning) to keep the bill from compounding.
• Pick New Relic if: You want predictable, boring observability bills. You're OTel-first or have heavy log volume. You have a finance team that hates surprises more than engineering hates UI friction. You're a startup on the free tier — it's genuinely the best free observability offering in 2026.
• Pick Dynatrace if: You run 500+ services across heterogeneous tech (Java, .NET, mainframe, SAP), MTTR is a CFO-visible metric, and you have the procurement muscle to negotiate DPS commits with confidence. Also: regulated industries that need OneAgent's security posture and immutable Grail storage.
• Pick OSS (Grafana Cloud, SigNoz, or self-hosted Prometheus + Tempo + Loki) if: You have platform engineering capacity, your service count is above 100 (below that, licensing savings don't justify ops overhead), and you're comfortable with the fuller context in cutting your AWS bill and AI observability for newer workloads.
• Stick with a hybrid if: You've outgrown Datadog's bills but can't justify the disruption of a full cut. Run logs and metrics on New Relic or OSS; keep Datadog for APM and RUM until the next contract cycle.

Frequently Asked Questions

Picking the APM That Fits Your Procurement Reality

Choosing between Datadog, New Relic, and Dynatrace in 2026 is less about which tool is "best" and more about which pricing model your finance team can live with. Datadog gives you the most polished tool with the most painful bill; New Relic gives you predictable economics with a merely functional UI; Dynatrace gives you AI-driven RCA with licensing complexity you re-negotiate every 18 months.

Model your actual telemetry volume for the next 12 months — hosts, custom metric cardinality, log GB/day, RUM sessions — then multiply by 1.3-1.5x for the bill shock that always arrives once engineers find new things to instrument. Negotiate 2-3 year commits aggressively at $15K+/month; discounts of 30-45% are standard. And audit your custom-metric cardinality before signing anything, regardless of vendor — it's the single biggest lever on enterprise APM bills.