The people who built Dash0 spent years inside a different kind of enterprise-observability machine before starting their own company. Founded in 2023 by veterans of Instana (the APM company IBM acquired in 2020), Dash0 hit unicorn status in March 2026 with a $110M Series B, grew to 600+ paying customers including Zalando and Taco Bell, and built its entire platform as a direct answer to a specific set of complaints: proprietary agents that lock you in, per-host billing that compounds with every product you enable, and OpenTelemetry support that exists mostly as an afterthought bolted onto a system designed before OTel existed.
Datadog is the platform those complaints are usually about. Not because it's poorly built, its APM, Continuous Profiler, Dynamic Instrumentation, and Cloud SIEM are all genuinely excellent, but because its commercial model is the industry's most-cited example of costs compounding: infrastructure at $15-23/host/month, APM at another $31-40/host/month on top of that, log ingestion and indexing billed separately, custom metric surcharges for teams using OpenTelemetry, and a high-water-mark billing model that can set your entire month's bill off a five-day traffic spike. A 100-host deployment with APM, logs, and RUM commonly runs $20,000-30,000/month.
Dash0's answer is architectural, not just financial: build OpenTelemetry-native from line one, price per million signals with zero minimum spend, and make the dashboards themselves (Perses, a CNCF standard) portable enough that lock-in stops being a lever the vendor can pull. It's a genuinely credible challenge from a team that's built this before. It's also three years old, missing Datadog's security platform entirely, and still shipping its flagship AI suite in beta. This comparison treats both facts as true at once.
| Feature | Datadog | Dash0 |
|---|---|---|
| Founded | 2010 | 2023 |
| Primary purpose | Full-stack observability + security platform | OpenTelemetry-native observability engine |
| Free tier | No (paid trial only) | Pure consumption, zero minimum |
| Pricing model | Per-host + per-GB + per-feature | Per million signals (logs, spans, metrics) |
| High-water mark billing | Yes (peak-of-month host count) | No (per-signal, no host concept) |
| Instrumentation | Proprietary DD Agent (OTel = custom metrics) | OTel operator (Java, Node.js, .NET) + manual SDKs |
| Query language | Proprietary (DQL) + some PromQL | PromQL |
| Query fees | No | No |
| Dashboard format | Proprietary | Perses (CNCF open standard) |
| APM pricing | $31-40/host/month (on top of infra) | $0.60 per million spans |
| Code-level profiling | Yes (Continuous Profiler) | No |
| Dynamic Instrumentation | Yes | No |
| Log management | Two-tier ($0.10/GB ingest + $1.70/M indexed) | $0.60/million records, no separate indexing |
| Infrastructure monitoring | Yes (deep, per-host, incl. NPM) | Yes (Kubernetes-native, resource-centric) |
| Kubernetes-as-code | Limited | Yes (PersesDashboard, PrometheusRule, SyntheticCheck CRDs) |
| Session replay | Yes | Early stage |
| Synthetic monitoring | Yes | Yes (with span correlation) |
| Error tracking | Yes (dedicated product) | No (via traces/logs) |
| Cloud SIEM / security | Yes (extensive: SIEM, CSPM, CIEM, workload protection) | No |
| Incident management | Yes (seat-based add-on) | Not included (external tools) |
| AI capabilities | Bits AI SRE (GA Dec 2025, autonomous) | Agent0 (beta, specialized agent federation) |
| MCP server | Yes (Preview) | No (Agent Skills instead) |
| Self-hosted / air-gapped | No | No (SaaS-only) |
| SOC 2 Type II | Yes | Yes |
| HIPAA | Yes | No |
| FedRAMP | Yes (GovCloud) | No |
Dash0's founders lived inside the enterprise observability machine at Instana before building the thing they wished had existed instead. That origin story explains almost every architectural choice in this comparison.
Datadog's integration is genuinely its strength: one agent collects everything, data from a Kubernetes pod, a database query, a browser session, a security alert, lands in one system, and correlating across signal types is seamless because Datadog controls the entire pipeline. The tradeoff is total: your data lives in Datadog's proprietary format, your dashboards are built in Datadog's query language, and if you use OpenTelemetry instead of the native agent, those metrics get billed as custom metrics, a real penalty for following the open standard Dash0 was built entirely around.
The billing compounds by design: infrastructure at $15-23/host/month is the foundation every other product stacks on top of, APM adds $31-40/host/month, logs split into $0.10/GB ingestion plus $1.70/million events to actually index, and high-water-mark billing means a traffic spike sets your rate for the entire month at peak host count.
Dash0 was designed to ingest, store, and query OpenTelemetry data without ever converting it to a proprietary shape, preserving full semantic richness, resource attributes, span relationships, the whole context Datadog's custom-metric surcharge implicitly treats as a cost center rather than a feature. Dashboards are built on Perses, a CNCF-backed open standard: what you build in Dash0 exports cleanly and imports elsewhere, a genuine zero-lock-in commitment that's structurally impossible for a platform whose business model depends on proprietary formats. The Kubernetes Operator auto-instruments Java, Node.js, and .NET; other runtimes need manual OTel SDK setup, real ongoing engineering work, but work that produces data you actually own.
Pricing is per million signals with zero minimum spend, no host concept at all, so there's no high-water mark to worry about and no per-host math to forecast. Unlimited seats too, an inversion of nothing (Datadog doesn't charge per seat either), but worth noting since Dash0 treats it as a first principle rather than an accident.
| Architectural factor | Datadog | Dash0 |
|---|---|---|
| Founding thesis | Integrated proprietary agent, one backend | Open standards, per-signal, zero lock-in |
| Data collection | Proprietary DD Agent (OTel = custom metrics) | OTel operator + manual SDKs |
| Query language | Proprietary DQL + some PromQL | PromQL |
| Dashboard format | Proprietary | Perses (CNCF open standard) |
| High-water mark billing | Yes | No (no host concept) |
| Custom metric / OTel surcharge | Yes | No (OTel is the native format) |
| Company maturity | 16 years, public, enterprise-scale | 3 years, unicorn, 600+ customers |
Datadog correlates everything automatically and Dash0 keeps your data open, but neither one gets anyone on the phone during an incident. Better Stack connects observability directly to on-call and incident response in one platform.
From heartbeat monitoring to incident timelines to status pages, one platform for the whole reliability lifecycle. Start free.
Datadog's APM is the deepest tooling in this entire comparison series. Dash0's is younger, OTel-only, and genuinely open in a way Datadog structurally can't match.
Datadog APM requires installing language-specific tracing libraries per service, and in exchange delivers real depth: service maps, Continuous Profiler for code-level CPU and memory attribution, Dynamic Instrumentation for adding log lines to production without redeploying, and Watchdog for automatic anomaly detection. None of that exists in Dash0 today, and for teams doing deep performance optimization work, that gap is not cosmetic.
The cost: $31-40/host/month on top of the infrastructure fee, with 150GB of ingested spans and 1 million indexed spans included per host, limits high-throughput services routinely exceed. And OpenTelemetry instrumentation, again, triggers custom metric surcharges.
Dash0's Trace Graph turns a trace into a functional architecture diagram rather than a flat waterfall, genuinely useful once a trace runs to thousands of spans. Synthetic metrics, error rates and latency percentiles derived from raw spans on demand, don't bill separately. The Kubernetes Operator auto-instruments Java, Node.js, and .NET; everything else needs manual OTel SDK setup, real work, but data that's never locked into a proprietary format.
What's missing entirely: Continuous Profiler-equivalent code-level profiling and Dynamic Instrumentation-equivalent live debugging. If either of those is core to your workflow, Dash0 simply doesn't offer them yet.
| APM / tracing | Datadog | Dash0 |
|---|---|---|
| Instrumentation | Proprietary SDK per service | OTel operator (3 runtimes) + manual SDKs |
| OTel treatment | Custom metric surcharge | Native, primary format |
| Code-level profiling | Yes (Continuous Profiler) | No |
| Dynamic Instrumentation | Yes | No |
| Trace visualization | Waterfall + service map | Waterfall + flame graph + Trace Graph |
| Data portability | Proprietary format | Full (OTel format, Perses dashboards) |
| APM pricing | $31-40/host/month | $0.60 per million spans |
Datadog charges per host and penalizes OpenTelemetry, and Dash0 asks your team to instrument every service by hand. Better Stack's eBPF-based tracing captures HTTP, gRPC, and database traffic at the kernel level with zero code changes, priced purely by data volume.
Full-fidelity distributed tracing from every service, priced by volume with no surprises. Explore Better Stack tracing.
Datadog's two-tier billing is the single most-cited pricing complaint in this entire comparison series. Dash0's per-signal model answers it directly, with its own tradeoff attached.
Datadog charges $0.10/GB to ingest logs, whether you ever search them or not, then $1.70 per million events to index them, which is what actually makes them queryable. Most teams ingest everything but index selectively, leaving a portion of logs archived and effectively invisible without a rehydration cost. At 100GB/day, the log bill alone approaches $107,000/year. The query experience justifies part of that cost: faceted search, Log Patterns clustering, Sensitive Data Scanner, seamless trace correlation.
Dash0 charges $0.60 per million log records regardless of size, so there's no ingest-versus-index decision at all, every log is searchable immediately. A verbose error log with a full stack trace costs exactly the same as a one-line health check, which actually rewards detailed logging rather than Datadog's model, where bigger logs cost more to ingest and get indexed selectively to control that cost. Spam Filters drop noisy telemetry before it counts against the bill, a genuinely useful lever. The catch runs the other way: very high-volume, low-content signals get expensive fast under per-signal pricing, and PromQL is the only query language, a real gap against Datadog's more approachable proprietary search DSL.
| Log management | Datadog | Dash0 |
|---|---|---|
| Pricing model | $0.10/GB ingest + $1.70/M indexed | $0.60/million records, all searchable |
| Two-tier indexing | Yes (indexed vs. archived) | No (one tier, always searchable) |
| Verbose vs. terse logs | Larger/more logs cost more | Same cost regardless of size |
| Pre-billing filtering | Observability Pipelines (routing) | Spam Filters (one-click) |
| Query language | Proprietary Log Search | PromQL only |
| Effective cost at scale | ~$2.50-3.00/GB (with indexing) | Depends on signal density |
Datadog's two-tier billing is the industry's most-cited pricing complaint, and Dash0's per-signal model has its own gotchas at high volume. Better Stack stores everything in one SQL-queryable warehouse at $0.10/GB with no separate indexing layer.
Unified log management with SQL search, live tail, and no indexing surprises. See how it works.
Datadog's infrastructure coverage is comprehensive across everything, cloud, on-prem, network. Dash0's is Kubernetes-only, and genuinely modern within that scope.
Datadog infrastructure monitoring starts at $15/host/month on Pro and covers host maps, deep Kubernetes monitoring, and Network Performance Monitoring tracking service-to-service traffic across availability zones, a category Dash0 doesn't offer at all. The high-water mark billing model applies here too: a five-day spike sets your rate for the whole month at peak host count.
Dash0's Kubernetes Operator synchronizes PrometheusRule and PersesDashboard CRDs directly from your cluster, meaning alerts, dashboards, and synthetic checks can be defined as Kubernetes resources, version-controlled in Git, and deployed through CI/CD, a materially more modern GitOps-native operating model than Datadog's dashboard-and-monitor console. Metrics run $0.20/million data points with 13-month retention and no cardinality penalty. The scope limit is real and total: no Windows agent, no on-prem network monitoring, nothing outside Kubernetes at meaningful depth.
| Infrastructure monitoring | Datadog | Dash0 |
|---|---|---|
| Network Performance Monitoring | Yes | No |
| Kubernetes-as-code (CRDs) | No | Yes (dashboards, alerts, synthetic checks) |
| Pricing model | Per-host ($15-23/month), high-water mark | Per million data points ($0.20/M) |
| Cardinality penalty | Yes (custom metrics) | No |
| Windows/on-prem coverage | Yes | No (Kubernetes-first) |
| Metric retention | Standard | 13 months |
Datadog's Bits AI SRE is GA and fires autonomously. Dash0's Agent0 is architecturally more ambitious but every piece of it is still beta.
Bits AI SRE went GA in December 2025 and fires the moment an alert triggers, investigating without prompting: reading runbooks, understanding topology, chaining hypotheses across logs, metrics, and traces in parallel. By the time you reach your laptop, it's often already produced a root cause hypothesis and sometimes a proposed fix. Around it sit Bits Chat, Bits Code, Bits Agent Builder, and Bits Security Analyst, all GA, plus an MCP Server still in Preview.
Agent0 is a genuinely distinctive architecture, six named, specialized agents rather than one generalist: the Seeker investigates alerts, the Oracle generates PromQL from natural language, the Pathfinder guides instrumentation of new services, the Threadweaver analyzes complex traces, the Architect generates dashboards and alert rules, and the Lookout surfaces problematic web sessions. Each agent exposes its own reasoning, making conclusions inspectable in a way Bits AI SRE's output doesn't necessarily show. It's exactly the kind of ambitious multi-agent bet a $110M Series B raised specifically to fund it would produce.
The honest gap: Bits AI SRE is GA and has been running in production incidents since December 2025; every piece of Agent0 is beta. There's also no MCP server at all for Dash0, notable since Datadog at least has one in Preview, and AI coding integration runs through Agent Skills and a CLI instead.
| AI capability | Datadog | Dash0 |
|---|---|---|
| Autonomous investigation | Yes (Bits AI SRE, GA Dec 2025) | Agent0's Seeker (beta) |
| MCP server | Yes (Preview) | None (Agent Skills + CLI instead) |
| Reasoning transparency | Agent Trace view (GA) | Yes, each agent exposes its reasoning |
| AI code review / editor integration | Bits Code (GA) | Agent Skills (Claude Code, Cursor, Windsurf) |
| Security AI | Bits Security Analyst (GA) | None (no security product at all) |
| Maturity | GA, production-hardened | Beta, all components |
Bits AI SRE is GA but still requires a separate paging tool, and Agent0 is ambitious but beta throughout. Better Stack's AI SRE activates autonomously during incidents and delivers its hypothesis into a live incident with the responder already paged, GA today.
Autonomous root cause investigation connected to on-call, incidents, and status pages. See the AI SRE.
This section resolves fast because the gap runs almost entirely one direction.
Datadog has a substantial security platform: Cloud SIEM, Workload Protection, App and API Protection, Code Security (SAST, IAST, SCA, secret scanning), CSPM, and CIEM. Dash0 has none of this, no SIEM, no threat detection, nothing, and has no near-term plan to build it based on its current roadmap focus.
Datadog's Digital Experience suite (Browser and Mobile RUM, Session Replay, Synthetic Monitoring, Product Analytics) is mature and a two-time consecutive Gartner Magic Quadrant Leader. Dash0's website monitoring, built on its own Web SDK and OpenTelemetry standards, covers Core Web Vitals and sessions but is, by the company's own admission, earlier stage: session replay is early, product analytics is limited, and there's no mobile RUM at all.
Error tracking follows the same pattern: Datadog has a dedicated product; Dash0 surfaces errors via span status codes and log records with no issue grouping.
| Gap | Datadog | Dash0 |
|---|---|---|
| Cloud SIEM / security platform | Yes (extensive) | No |
| Dedicated error tracking | Yes | No (via traces/logs) |
| Mobile RUM | Yes | No |
| Session replay | Yes (mature) | Early stage |
| Network Performance Monitoring | Yes | No |
| Incident management / on-call | Yes (seat-based add-on) | No (external tools) |
| Free tier | No | Yes (zero minimum) |
| High-water mark billing | Yes | No |
Scenario: 100 hosts, Kubernetes-heavy stack, moderate telemetry volume, APM enabled
| Cost component | Datadog (Pro, annual) | Dash0 (per-signal) |
|---|---|---|
| Infrastructure (100 hosts) | $1,500/month | N/A (billed via signal volume) |
| APM (100 hosts) | $3,100/month | ~$200-400/month ($0.60/M spans) |
| Logs (moderate volume) | ~$3,600/month (ingest + indexing) | ~$300-500/month ($0.60/M records) |
| Metrics | Custom metric charges apply | ~$100-200/month ($0.20/M data points) |
| Estimated monthly total | ~$8,200/month | ~$600-1,100/month |
The gap is dramatic, roughly 8-13x, and it's the largest cost gap in this comparison series because Datadog's per-host, high-water-mark, two-tier-log model compounds in exactly the ways this whole series has documented. Dash0's zero-minimum, per-signal model has no equivalent compounding mechanism.
The asterisk still matters: this comparison covers observability only. Datadog's total here doesn't include Cloud SIEM, session replay, or error tracking as separate line items, and if you enable them the gap widens further in Datadog's disfavor. But Dash0's total also excludes anything approaching Datadog's security platform or dedicated error tracking, because it doesn't offer them at any price. Compare total capability against your actual requirements, not just the number.
| Pricing factor | Datadog | Dash0 |
|---|---|---|
| Free tier | No | Zero minimum, pure consumption |
| Cost anchored to | Host count + ingest + features | Signal count (logs, spans, metrics) |
| High-water mark billing | Yes | No (no host concept) |
| Custom metric surcharges | Yes | No |
| Query fees | No | No |
| Self-serve start | Trial only | Yes |
Dash0's per-signal model avoids every compounding mechanism in Datadog's pricing, but neither platform pages your on-call engineer. Better Stack combines volume-priced logs, metrics, and traces with on-call scheduling, incident management, and status pages, one platform, one bill.
Fewer vendors, fewer context switches, and a single place for the full reliability workflow. Talk to us.
There's a version of this decision that resolves in about ten seconds: does your evaluation include security operations, code-level profiling, mature session replay, or dedicated error tracking with issue grouping? If yes, Dash0 simply doesn't have those things yet, at any price, and no amount of per-signal pricing elegance changes that. Datadog's breadth is real, earned over sixteen years, and for organizations that need Cloud SIEM alongside observability in one procurement decision, this comparison is close to moot.
The harder, more interesting version of the decision applies to teams whose requirements actually sit inside what Dash0 already covers: Kubernetes-native infrastructure, logs, metrics, traces, no security platform requirement, no mobile RUM need. For that team, the founders' Instana scar tissue shows up as genuine product advantages: OpenTelemetry data that's never locked into a proprietary shape, Perses dashboards that survive a vendor switch, and a pricing model with no high-water mark, no custom metric surcharge, and no minimum spend to negotiate around. The cost gap at that profile, 8-13x in this scenario, isn't a rounding error, it's the entire argument.
The honest caution in the other direction: Dash0 is three years old, its flagship AI suite is beta throughout, and betting production incident response on a beta product is a real bet, not a foregone conclusion just because the founders have done this before. Datadog's Bits AI SRE has been running against real production incidents since December 2025. Agent0 hasn't yet. For a team choosing today, that maturity gap is worth weighing as seriously as the pricing gap.
Neither Datadog nor Dash0 includes on-call scheduling with phone and SMS, incident management, or customer-facing status pages as part of the core platform. Better Stack brings all of that together with logs, metrics, and traces, with usage-based pricing and no per-host, per-signal, or high-water-mark surcharges.
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.
detailed comparison of Better Stack and Dash0 covering pricing, architecture, distributed tracing, log management, Kubernetes monitoring, incident management, AI SRE agents, and more. Find out which platform fits your team.
Top 10 Dash0 alternatives in 2026. Compare Better Stack, Datadog, Dynatrace & more observability platforms. Find the best monitoring solution.
Dynatrace vs Dash0 compared across APM, log management, Kubernetes monitoring, AI capabilities, and pricing. How the enterprise observability incumbent stacks up against the OpenTelemetry-native challenger from Instana's founding team.
New Relic vs Dash0 compared across APM, log management, Kubernetes monitoring, AI capabilities, and pricing. How seat-based unified observability stacks up against OpenTelemetry-native, per-signal pricing from Instana's founding team.
We use cookies to authenticate users, improve the product user experience, and for personalized ads. Learn more.