New Relic and Dynatrace were the two defining APM vendors of the 2010s, and both spent the last several years rebuilding themselves, just in completely different directions. New Relic blew up its business model: it scrapped per-host pricing in 2020 and moved everything to a consumption model built on two numbers, data ingest and user seats. Dynatrace blew up its platform: it rebuilt storage around Grail, a schema-on-read data lakehouse, and wrapped its pricing into the Dynatrace Platform Subscription, a rate card that meters consumption across memory-GiB-hours, host-hours, GiB-days, GiB-scanned, pod-hours, and per-session charges.
Those two rebuilds produced pricing models that fail in opposite ways. New Relic's bill is easy to predict and gets expensive through one visible mechanism: seats. Full platform access costs $349/month per engineer on Pro, so a 20-person on-call rotation costs $6,980/month before telemetry. Dynatrace's bill is granular and gets expensive through a dozen quiet mechanisms at once: a 64 GiB production host costs 8x what an 8 GiB host costs for Full-Stack Monitoring, log queries are metered per GiB scanned on the pay-per-query plan, and every capability from Kubernetes pods to session replay to runtime security has its own line on the rate card. One model concentrates the cost where you can see it. The other distributes it where you often can't.
The capability comparison underneath is genuinely close, which is what makes this one of the hardest decisions in enterprise observability. Both platforms have deep APM with code-level visibility. Both have mature AI stories: Dynatrace's Davis has been doing deterministic, topology-aware root cause analysis since 2017, while New Relic's SRE Agent (Preview, February 2026) fires autonomous investigations at alert time. Both hold FedRAMP Moderate, HIPAA, and the compliance certifications that enterprise procurement demands. The differences that decide this comparison live in the details: instrumentation philosophy, query cost mechanics, security products, and what kind of complexity your organization tolerates best.
| Feature | New Relic | Dynatrace |
|---|---|---|
| Primary purpose | Unified full-stack observability SaaS | Enterprise observability + security platform |
| Free tier | Yes (100GB/month + 1 full platform user, forever) | 15-day trial only |
| Pricing model | Per-user + data ingest (GB) | Consumption rate card (DPS) |
| Cost scales primarily with | Engineer headcount + ingest | Host memory, data volume, queries, capabilities |
| Query language | NRQL (unified) | DQL (unified via Grail) |
| APM instrumentation | APM agents, eBPF (eAPM), or OTel | OneAgent (auto-inject) or OTel |
| Code-level profiling | Yes (thread profiling) | Yes (PurePath, method-level) |
| Distributed tracing | Yes (Infinite Tracing) | Yes (PurePath) |
| Log management | Yes ($0.40/GB, all searchable, no query fees) | Yes ($0.20/GiB + retention + query fees or bundled) |
| Infrastructure monitoring | Yes | Yes (deep, incl. mainframe, SAP, VMware) |
| Topology mapping | Service maps + entity relationships | Smartscape (automatic, real-time) |
| Real user monitoring | Yes (Gartner DEM Leader, 2x) | Yes (web + mobile + session replay) |
| Synthetic monitoring | Yes | Yes (browser + HTTP monitors) |
| AI root cause analysis | Applied Intelligence (GA) + SRE Agent (Preview) | Davis AI (deterministic, since 2017) |
| Autonomous AI investigation | Yes (SRE Agent, fires on alert, Preview) | Yes (Davis + agentic AI agents, some Preview) |
| MCP server | Yes (Preview) | Yes (GA, remote + local, query costs apply) |
| Application security | Limited (Security RX, preview) | Yes (runtime vulnerability + protection + posture) |
| On-call scheduling | Via New Relic On-Call or integrations | Via PagerDuty/ServiceNow/external |
| Status pages | No | No |
| SOC 2 Type II | Yes | Yes |
| HIPAA | Yes (Data Plus) | Yes |
| FedRAMP | Yes (Moderate, expanding to High) | Yes (Moderate) |
| ISO 27001 | No | Yes |
| PCI DSS | No | No (not standard portfolio) |
| OTel support | Yes (native, no surcharge) | Yes (counted toward consumption) |
New Relic puts logs, metrics, traces, and events into NRDB and makes everything queryable through NRQL. The investigation experience follows directly from that design: an alert fires and you click from the alert to the APM trace to the surrounding logs to the infrastructure state without switching interfaces or query languages. RUM and APM share the same backend, so frontend-to-backend correlation requires no configuration.
The pricing is deliberately simple: $0.40/GB for ingest past the free 100GB/month, and $349/month per full platform user on Pro. There are no query fees, no retention micro-charges, and no per-capability line items. The simplicity has one sharp edge: every engineer who needs full investigative access needs a seat, and seat costs compound with team size faster than any other single factor.
Dynatrace's architecture rests on three genuinely impressive pieces of engineering. OneAgent installs on each host, auto-discovers running processes, and injects monitoring code at runtime, providing code-level visibility that includes CPU profiling, memory allocation tracking, and method-level hotspot detection through PurePath. Smartscape automatically discovers and maps dependencies across the entire environment in real time, producing the topology graph that powers everything else. Grail, the data lakehouse, stores logs, traces, metrics, and events with schema-on-read querying through DQL, eliminating the hot/cold storage distinction and index management that older architectures require.
The consumption model prices each capability separately. Full-Stack Monitoring runs $0.01 per memory-GiB-hour (about $58/month for an 8 GiB host), Infrastructure-only runs $29/month per host, Kubernetes pods add $0.002 per pod-hour, log ingestion costs $0.20/GiB with retention and query charges on top, and RUM, synthetics, and Application Security each have their own rates. The granularity is transparent in the rate card and opaque in practice: forecasting next month's bill requires predicting consumption across many independent dimensions, and a 64 GiB database server costs 8x an 8 GiB web server for the same Full-Stack coverage.
The log query mechanics deserve specific attention. On the pay-per-query plan, retention costs $0.0007/GiB-day but every query costs $0.0035 per GiB scanned, which means investigating an incident more thoroughly costs more money. The bundled-queries plan removes the per-scan charge but prices retention at $0.02/GiB-day, roughly 28x higher. Teams must predict their query patterns before signing to choose correctly.
| Architectural factor | New Relic | Dynatrace |
|---|---|---|
| Data storage | NRDB (unified) | Grail (data lakehouse, schema-on-read) |
| Query language | NRQL | DQL |
| Instrumentation | APM agents, eBPF (eAPM), or OTel | OneAgent (auto-inject) or OTel |
| Topology mapping | Entity relationships | Smartscape (automatic, real-time) |
| Query fees | None | $0.0035/GiB-scanned (pay-per-query logs/traces) |
| Host-size pricing | No | Yes (memory-GiB-hours for Full-Stack) |
| Billing dimensions | Two (seats + ingest) | Many (per capability) |
| Cost predictability | High (seat count dominates) | Lower (consumption fluctuates) |
Both platforms detect problems and stop before owning the response. Neither includes built-in on-call scheduling with phone and SMS delivery or customer-facing status pages. Better Stack brings all of that together alongside logs, metrics, and traces, so you can go from alert to post-mortem without switching tools.
From heartbeat monitoring to incident timelines to status pages, one platform for the whole reliability lifecycle. Start free.
This is the category both companies built their reputations on, and both remain excellent. The differences are in instrumentation philosophy and what depth costs.
New Relic offers language-specific APM agents with thread-level CPU profiling, plus eBPF-based eAPM for zero-code Kubernetes instrumentation. Infinite Tracing retains the most significant traces out of 100% of collected data rather than sampling blindly, which matters for catching the rare slow request that sampling would miss. APM 360 connects frontend sessions to backend traces within the same interface. OTel is native with no surcharge, which distinguishes New Relic from both Datadog and, in a subtler way, Dynatrace, where OTel data counts toward metered consumption.
OneAgent's auto-instrumentation depth remains unmatched in the category. Install it on a host and it discovers processes, injects monitoring code, and begins capturing PurePath traces that follow individual transactions from the browser through every service call and database query down to the specific method responsible for latency. For performance engineering teams doing deep optimization work on JVM or .NET applications, the method-level flame graphs and thread contention analysis are capabilities New Relic's thread profiling approaches but doesn't fully match.
The tradeoff is proprietary depth versus portability. The more deeply your workflows integrate with PurePath and Smartscape, the harder it becomes to leave. OTel is supported for ingestion, but native OneAgent instrumentation remains the primary path, and your traces live in Grail's format, queryable through DQL. Also worth noting: trace queries on the pay-per-query model incur GiB-scanned charges, meaning heavy trace investigation carries a metered cost that New Relic doesn't impose.
| APM / tracing | New Relic | Dynatrace |
|---|---|---|
| Instrumentation | APM agents, eBPF (eAPM), or OTel | OneAgent (auto-inject) or OTel |
| Code-level profiling | Yes (thread profiling) | Yes (PurePath, method-level, deeper) |
| Trace retention approach | Infinite Tracing (smart retention) | 10 days included, extendable to 10 years |
| Trace query fees | None | $0.0035/GiB-scanned (pay-per-query) |
| OTel treatment | Native, no surcharge | Supported, counts toward consumption |
| Frontend-to-backend | Seamless (shared NRDB) | Seamless (RUM + PurePath correlation) |
| APM pricing | Included in ingest + user license | $0.01/memory-GiB-hour (Full-Stack) |
New Relic charges per engineer who needs access, and Dynatrace charges based on how much memory your hosts have. Better Stack's tracing is priced purely by data volume with no per-seat fees, no host-size multipliers, and no query charges, and the AI SRE activates automatically during incidents to investigate root cause before you have to ask.
Full-fidelity distributed tracing from every service, priced by volume with no surprises. Explore Better Stack tracing.
Both platforms make all ingested logs searchable without traditional indexing gates. The meaningful difference is what querying costs.
New Relic charges $0.40/GB past the 100GB/month free tier, and every log is searchable through NRQL with no per-query charges. Investigate an incident with fifty broad queries or five narrow ones; the bill is identical. Seven-year retention without rehydration is available for compliance use cases. AI alert summarization generates hypotheses when log-triggered alerts fire, and cross-signal correlation works naturally because logs share NRDB with traces and metrics.
Dynatrace's log ingest at $0.20/GiB is half New Relic's rate, and Grail's schema-on-read querying means no field indexing or parser configuration upfront. DQL handles on-read parsing, aggregation, and cross-signal correlation with topology enrichment from Smartscape, which adds genuinely useful context to log investigation.
The cost structure gets complicated after ingest. On pay-per-query, retention is cheap ($0.0007/GiB-day) but every DQL query scans data at $0.0035/GiB. On bundled queries, retention costs $0.02/GiB-day, roughly 28x more, with querying included and retention capped at 10 to 35 days on the included plan. The choice requires predicting whether your team investigates broadly and frequently (bundled wins) or narrowly and rarely (pay-per-query wins), and the wrong guess costs real money. During a major incident, the pay-per-query model creates a perverse dynamic: the more thoroughly your team investigates, the more the investigation costs.
| Log management | New Relic | Dynatrace |
|---|---|---|
| Ingest rate | $0.40/GB (100GB/month free) | $0.20/GiB |
| Query fees | None | $0.0035/GiB-scanned or bundled |
| Retention pricing | Included in model | $0.0007 or $0.02/GiB-day (model-dependent) |
| Max retention | 7 years, no rehydration | 10 years (usage-based) |
| Query language | NRQL | DQL (topology-enriched) |
| Upfront plan decision | None | Pay-per-query vs bundled |
New Relic charges more per GB, and Dynatrace meters your queries or your retention. Better Stack stores logs in a unified warehouse with SQL querying, no per-event charges, and no scan fees. You pay for what you send, and all of it is searchable as many times as an incident requires.
Unified log management with SQL search, live tail, and no indexing surprises. See how it works.
Both platforms cover cloud infrastructure comprehensively. Dynatrace covers considerably more beyond the cloud.
New Relic covers Linux, Windows, and macOS with no-agent cloud integrations for AWS, Azure, and GCP, and solid Kubernetes monitoring. Infrastructure data is included in the ingest-plus-seats model with no per-host fees. The consistent New Relic caveat applies: viewing infrastructure data during an incident requires a full platform seat, so an engineer without one provisioned can't see host metrics at 2am.
Dynatrace monitors everything New Relic does, plus the environments most cloud-native platforms ignore: mainframes, SAP systems, VMware Tanzu, and hybrid data center estates. Smartscape's automatic topology mapping across all of it is genuinely differentiated for large enterprises with thousands of interconnected services spanning decades of infrastructure generations. The tiered monitoring modes (Foundation & Discovery at $7/month per host, Infrastructure at $29/month, Full-Stack at $58/month per 8 GiB host) let organizations match coverage depth to host criticality.
The memory-based pricing catch: Full-Stack Monitoring bills per memory-GiB-hour, so large-memory hosts cost proportionally more. A 64 GiB database server runs roughly $467/month for Full-Stack coverage versus $58 for an 8 GiB host. Kubernetes pods add $0.002/pod-hour ($1.40/month per pod) unless the host runs Full-Stack. Cloud integrations pull in thousands of metrics by default, with custom metrics billed at $0.15 per 100k datapoints, and teams frequently discover cloud metric costs they never explicitly enabled.
| Infrastructure monitoring | New Relic | Dynatrace |
|---|---|---|
| Pricing | Included in ingest + user license | $7-$58+/month per host (mode + memory dependent) |
| Host-size pricing | No | Yes (memory-GiB-hours for Full-Stack) |
| Mainframe / SAP / VMware | No | Yes |
| Kubernetes | Yes | Yes ($0.002/pod-hour or included with Full-Stack) |
| Topology mapping | Entity relationships | Smartscape (automatic, real-time) |
| Access model | Full platform seat required | Included with subscription |
Both platforms have complete DEM suites. New Relic carries the analyst recognition; Dynatrace prices each piece on the rate card.
New Relic covers Browser RUM, Mobile RUM across iOS, Android, React Native, and Flutter, Session Replay, Synthetic Monitoring, Product Analytics, and Experiments, and is a two-time consecutive Gartner Magic Quadrant Leader for DEM. Correlation with backend traces is seamless through the shared NRDB backend.
Dynatrace covers web and mobile RUM with crash analysis at $2.25 per 1,000 sessions, session replay at $4.50 per 1,000 sessions with replay capture, browser synthetics at $4.50 per 1,000 actions, and HTTP monitors at $1 per 1,000 requests. The RUM-to-PurePath correlation is excellent: a slow user session connects directly to the backend transaction that caused it with code-level context. At high traffic volumes, the per-session math deserves attention: 5 million monthly sessions with replay run $22,500/month at list rates.
| Digital experience | New Relic | Dynatrace |
|---|---|---|
| Browser RUM | Yes (Gartner DEM Leader, 2x) | Yes ($2.25/1,000 sessions) |
| Mobile RUM | Yes (iOS, Android, React Native, Flutter) | Yes (with crash analysis) |
| Session replay | Yes | Yes ($4.50/1,000 sessions) |
| Synthetic monitoring | Yes | Yes (browser + HTTP, per-action pricing) |
| Backend correlation | Seamless (shared NRDB) | Seamless (RUM + PurePath) |
This is one of the most interesting sections of the comparison because the two platforms represent different generations of AI thinking that are now converging.
Davis AI predates the LLM era and works differently from most observability AI. It performs deterministic fault-tree analysis across the Smartscape topology graph, correlating events that share a root cause into a single problem rather than an alert storm. When a deployment fails and cascades through six services, Davis traces the causal chain from the deployment event through the dependency graph to the user-facing symptoms, with reproducible reasoning rather than probabilistic pattern-matching. This has been in production for years and is the most battle-tested root cause engine in the category.
Dynatrace Intelligence now layers agentic AI on top: Davis CoPilot converts natural language to DQL and assists with dashboards, an SRE Agent investigates alerts autonomously, a Developer Agent proposes fixes linked to builds (Preview), and a Security Agent triages vulnerabilities. AutomationEngine connects detection to automated remediation workflows. The Dynatrace MCP server is GA in both remote and local versions, connecting Claude, Cursor, VS Code, GitHub Copilot, and Amazon Q to Dynatrace data, with one caveat: MCP queries run against Grail and incur GiB-scanned charges, so AI-driven investigation carries metered costs.
New Relic's SRE Agent, launched February 2026, fires automatically when an alert triggers and investigates without prompting: querying traces, reviewing logs, checking recent deployments, and producing a root cause hypothesis by the time you open your laptop. The Agentic Platform adds a no-code agent builder, orchestration, and MCP support. Applied Intelligence, which groups related alerts and generates summaries, is GA and has been for some time.
The honest comparison: Dynatrace's Davis is more mature, more deterministic, and processes the topology graph in a way New Relic doesn't replicate. New Relic's SRE Agent is architecturally similar to where the industry is heading but remains in Preview, as does most of the Agentic Platform. For teams making a decision on shipping AI capabilities today, Dynatrace's are further along. New Relic's MCP server is also still in Preview while Dynatrace's is GA.
| AI capability | New Relic | Dynatrace |
|---|---|---|
| Root cause engine | Applied Intelligence (GA) | Davis AI (deterministic, topology-aware, since 2017) |
| Autonomous investigation | SRE Agent (Preview, fires on alert) | Davis + SRE Agent (agentic layer, some Preview) |
| Natural language querying | Via Agentic Platform (Preview) | Davis CoPilot (GA) |
| MCP server | Preview | GA (remote + local) |
| MCP query costs | None | GiB-scanned charges apply |
| Automated remediation | Limited | AutomationEngine workflows |
| Maturity | Newer, mostly Preview | Battle-tested, years in production |
Both platforms have serious AI investigation capabilities. What neither one includes is a direct path from a root cause hypothesis to an on-call notification, an incident timeline, and a customer-facing status page update. Better Stack's AI SRE connects to the full incident lifecycle so the investigation and the response happen in the same place.
Autonomous root cause investigation connected to on-call, incidents, and status pages. See the AI SRE.
Dynatrace has a real security product line. New Relic has a compliance posture and a preview feature.
Dynatrace Application Security leverages OneAgent's runtime visibility for something most security scanners can't do: it detects which vulnerable libraries are actually loaded in running production processes and whether the vulnerable code paths are reachable, prioritizing by real exposure rather than theoretical CVSS scores. Runtime Vulnerability Analytics runs $13/month per 8 GiB host, Runtime Application Protection (which blocks exploitation attempts in real time) adds another $13/month per 8 GiB host, and Security Posture Management at $5/month per host checks compliance against CIS, NIST, DORA, and HIPAA standards. Threat Observability combines security signals with observability data for investigation.
New Relic's Security RX, previewed in 2026, correlates vulnerability findings with engineering context. It is a correlation feature, not runtime protection or threat detection. For organizations where application security is part of the observability platform evaluation, Dynatrace offers a genuine product suite and New Relic does not.
The compliance portfolios differ too: both hold SOC 2, HIPAA, and FedRAMP Moderate, but Dynatrace adds ISO 27001, IRAP, TISAX, and FIPS 140-3, which matters for international and defense-adjacent procurement.
| Security | New Relic | Dynatrace |
|---|---|---|
| Runtime vulnerability detection | No | Yes ($13/month per 8 GiB host) |
| Runtime application protection | No | Yes ($13/month per 8 GiB host) |
| Security posture management | No | Yes (CIS, NIST, DORA, HIPAA) |
| SOC 2 Type II | Yes | Yes |
| HIPAA | Yes (Data Plus) | Yes |
| FedRAMP | Yes (Moderate, expanding to High) | Yes (Moderate) |
| ISO 27001 | No | Yes |
| IRAP / TISAX / FIPS 140-3 | No | Yes |
The structural difference matters more than any single number: New Relic's cost concentrates in seats, Dynatrace's distributes across consumption dimensions.
Scenario: 100 hosts (8 GiB average), 15 engineers needing full access, 500GB/month logs
| Cost component | New Relic (Pro, annual) | Dynatrace (DPS, list rates) |
|---|---|---|
| Platform / host monitoring | $0 (no per-host fee) | ~$5,840/month (Full-Stack, 100 x 8 GiB) |
| User licenses | $5,235/month (15 x $349) | $0 (no seat fees) |
| Log ingest (500GB) | ~$160/month (minus free tier) | ~$100/month |
| Log retention + queries | Included | ~$300-400/month (model-dependent) |
| Kubernetes (200 pods) | Included | Included with Full-Stack |
| Traces | Included | Allowance included, queries metered |
| On-call (5 responders) | Via New Relic On-Call or PagerDuty | PagerDuty (~$245-415/month) |
| Estimated monthly total | ~$5,640-5,810/month | ~$6,485-6,755/month |
At this profile the totals land surprisingly close, which is why the decision usually turns on the shape of your organization rather than the total. Flip the variables and the picture changes fast: a 5-engineer team with the same 100 hosts pays New Relic roughly $1,905/month while Dynatrace stays near $6,500, because Dynatrace's cost is anchored to infrastructure, not people. Conversely, a 40-engineer organization with 30 small hosts pays Dynatrace modestly while New Relic's seat bill alone approaches $14,000/month.
Two structural cautions. Dynatrace requires a minimum annual commitment (reportedly around $24,000/year), and enterprise discounts off list rates are standard but require negotiation. New Relic's free tier (100GB and one full user, forever) remains the most generous evaluation path in enterprise observability; Dynatrace offers a 15-day trial.
| Pricing factor | New Relic | Dynatrace |
|---|---|---|
| Free tier | Yes (100GB + 1 user, forever) | 15-day trial |
| Cost anchored to | Engineer headcount | Host memory + consumption |
| Per-seat fee | $349/month (full platform, Pro) | None |
| Host-size sensitivity | None | High (memory-GiB-hours) |
| Query fees | None | Logs/traces on pay-per-query |
| Minimum commitment | None | ~$24,000/year reported |
| Bill predictability | High | Requires consumption forecasting |
Both New Relic and Dynatrace require separate tools for on-call scheduling and status pages. Better Stack consolidates logs, metrics, traces, on-call scheduling, incident management, and status pages into one platform with one bill.
Fewer vendors, fewer context switches, and a single place for the full reliability workflow. Talk to us.
New Relic gaps worth knowing:
Dynatrace gaps worth knowing:
These are the two most capable enterprise observability platforms in the market, and the decision between them usually turns on three organizational questions rather than a feature checklist.
The first is what your infrastructure looks like. If your estate includes mainframes, SAP, VMware, and decades of hybrid infrastructure alongside cloud-native workloads, Dynatrace monitors all of it under one platform with automatic topology mapping, and New Relic simply doesn't cover that ground. If you're purely cloud-native, that Dynatrace advantage is irrelevant and its pricing complexity buys you nothing.
The second is the shape of your team relative to your infrastructure. Many engineers on modest infrastructure favors Dynatrace's no-seat model. Few engineers on large infrastructure favors New Relic's no-host-fee model. Run both calculations with your real numbers before any demo, because the structural difference dominates everything else in the bill.
The third is how much operational complexity your organization absorbs well. Dynatrace rewards organizations with the discipline to manage consumption budgets, choose log retention models correctly, and invest in DQL fluency; it punishes organizations that deploy it and hope the bill behaves. New Relic asks much less operationally: two billing dimensions, one query language with a gentler curve, and a free tier that lets you validate everything before spending a dollar. Teams that just want excellent observability without a platform management function tend to be happier there.
On AI, Dynatrace ships the more mature capability today: Davis has been doing deterministic root cause analysis in production for years, Davis CoPilot and the MCP server are GA, and the agentic layer builds on a proven foundation. New Relic's SRE Agent is architecturally compelling and fires proactively at alert time, but it remains in Preview, and buying against a preview is a bet rather than a purchase.
Neither New Relic nor Dynatrace includes uptime monitoring, on-call scheduling with phone and SMS, incident management, and customer-facing status pages as a unified product. Better Stack brings all of that together with logs, metrics, and traces, with usage-based pricing and no per-seat or per-host fees.
The full reliability lifecycle in one place. Start free, no credit card required. Try Better Stack.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
Better Stack and Dynatrace compared across pricing, architecture, APM, log management, infrastructure monitoring, incident management, AI, RUM, security, and enterprise readiness. Covers Dynatrace's DPS consumption model, Davis AI, Grail data lakehouse, and OneAgent versus Better Stack's eBPF instrumentation, unified storage, and volume-based pricing.
Dynatrace offers a good solution for log management, but there is still a room for improvement. Let's take a look at the list of alternatives offering more friendly prices, easier onboarding, better design and more.
We use cookies to authenticate users, improve the product user experience, and for personalized ads. Learn more.