The One-Line Truth

Dash0 collects logs, metrics, and traces through OpenTelemetry, then deploys specialized AI agents to diagnose and fix production incidents before engineers are paged.

The Role: Site Reliability Engineer / Platform Engineer / DevOps Lead Founded: 2023 | HQ: New York (founded in Germany, team across US and Europe) | Funding: $155M total ($9.5M Seed, $35M Series A, $110M Series B at $1B valuation) Founders: Mirko Novakovic (CEO, previously co-founded Instana, acquired by IBM in 2020 in a deal widely reported at ~$500M though terms were not publicly disclosed; co-founded codecentric; University of St. Gallen; 85+ B2B investments via New Forge) and Ben Blackmore (CTO, previously at codecentric and Instana)

The Disruption Connection

In December, The Heed Report mapped how AI was reshaping every layer of the business stack, from revenue generation through the infrastructure that protects it. One signal was clear across every layer: the tools that monitor modern systems were becoming more expensive than the problems they existed to catch.

Dash0 is what happens when the team that built one of the most successful observability companies of the last decade looks at the market they helped create and decides the entire architecture needs to be rebuilt from open standards up.

The Problem It Kills

Observability has become a tax. In modern cloud-native environments, monitoring costs can account for up to 20% of an organization's total cloud expenditure (Dash0 Series B announcement, citybiz). The incumbents who dominate this market, Datadog and Dynatrace chief among them, have built pricing models around per-host fees, per-GB ingestion charges, and per-seat licenses that penalize teams for doing exactly what observability requires: collecting high-fidelity data across distributed systems.

The cost problem is compounded by a toil crisis. Engineering teams spend disproportionate hours building dashboards, configuring alerts, and manually correlating traces with logs during incidents. When a system generates millions of events per minute, the cognitive load of sifting through that noise exceeds what any human team can sustain. Traditional observability tools have become, as Mirko Novakovic puts it, "too noisy, too expensive, and too complex" (Series A announcement).

The pricing structure matters. Datadog charges approximately $15 per host for infrastructure monitoring and $31 per host for APM, with additional fees for log ingestion, indexing, and custom metrics. A 50-person engineering team running 20 microservices can easily spend $2,500 to $4,000 per month on a comparable Datadog deployment. Dash0 charges $0.20 per million metric data points and $0.60 per million spans or log records, with no per-seat fees and no base platform charge. The same workload generating 500 million metrics, 800 million spans, and 400 million log records per month would cost approximately $820 on Dash0.

The difference is not just price. It is architectural. Dash0 was built natively on OpenTelemetry, which means there is no proprietary translation layer between the data collected and the data stored. Every attribute and resource tag survives intact. When AI agents reason over that data, they work with the full context rather than a lossy proprietary representation.

Who This Is For / Who Should Skip It

Build with this if: You run a platform engineering or SRE team managing Kubernetes-native microservices and you have already committed to or are transitioning toward OpenTelemetry. Your team is mid-market to enterprise scale. You are spending more on observability than you believe the insights justify. You want AI-assisted incident triage without abandoning open standards. You use Prometheus and PromQL today and want a unified backend that extends that query language across logs and traces, not just metrics. You run significant AWS Lambda workloads and need serverless observability alongside container monitoring (strengthened by Dash0's Lumigo acquisition in February 2026).

Skip this if: Your infrastructure is primarily on-premise and non-containerized, where Dash0's OpenTelemetry-native strengths offer limited advantage. Skip it if you need a single platform that includes on-call scheduling, SMS paging, and status pages alongside observability. Dash0 is a monitoring and diagnosis platform, not an incident management suite. You would still need PagerDuty or incident.io alongside it. Skip it if your team relies on the deep auto-instrumentation of a proprietary agent like Dynatrace's OneAgent and is unwilling to manage OpenTelemetry instrumentation directly. And skip it if you need a generous free tier for a small project. Unlike New Relic's 100GB per month free offering, Dash0's 14-day trial converts to pure consumption pricing with no permanent free volume.

How It Actually Works

Minute 1. You sign up for the 14-day free trial (no credit card required) and land in a clean, dark-mode-default interface. Dash0 offers a built-in OpenTelemetry demo application so you can explore the platform immediately without connecting your own infrastructure. The UI is keyboard-first: nearly every action can be performed without touching a mouse, which matters during high-pressure incident response.

First Hour. The primary onboarding path is the Dash0 Kubernetes Operator. Deploy it into your cluster and it automatically injects the OpenTelemetry Collector, auto-instrumenting workloads for Java, Node.js, and .NET. For non-Kubernetes environments or unsupported languages, you configure the standard OpenTelemetry SDKs to point at Dash0's OTLP endpoint. Within minutes of instrumentation, traces, logs, and metrics begin flowing into a unified view. PromQL works natively across all three signal types, so if your team already writes Prometheus queries, there is no new query language to learn. Agent0, Dash0's AI agent platform, is enabled by default and begins scanning the incoming telemetry stream immediately.

First Week. This is where the SIFT framework becomes tangible. The Spam filter identifies redundant signals (health check logs, repetitive heartbeats) and lets you suppress them in two clicks before they are stored or billed. The Ingest layer structures data according to OpenTelemetry semantic conventions. The Filter stage enriches with resource metadata. The Triage engine compares current data against historical baselines to surface anomalies. When Agent0 detects an error pattern, it initiates a root-cause investigation: correlating the specific trace ID of a failed request with the logs from the corresponding pod and the metrics of the underlying node. The output surfaces as guided actions rather than raw data. Dashboards and alerts can be managed as code via Kubernetes CRDs, Terraform (dash0hq/terraform-provider-dash0), or CLI, keeping observability configuration in your release pipeline alongside application code.

The Features That Matter

Agent0: The AI SRE Platform. Agent0 is not a single chatbot but a family of specialized agents, each with a distinct role. The AI SRE Agent performs autonomous root-cause analysis by correlating traces, logs, and metrics across services. The Observability Toil Agent auto-creates dashboards, alerts, and SLOs, keeping them updated as your stack changes. The Migration Agent helps teams transition from legacy vendors by mapping existing dashboard and alert logic to OpenTelemetry equivalents. Cost, Security, and Deployment agents handle infrastructure spend optimization, anomaly detection, and release validation respectively. Agent0 launched in November 2025 and is currently free during the beta phase. The limitation: it works best in environments with rich, consistent OpenTelemetry metadata. Without complete instrumentation, its reasoning defaults to probabilistic suggestions rather than definitive root causes. (Dash0 Agent0 launch blog, November 2025; Series B announcement)

Telemetry Spam Filter. The most pragmatic cost-control feature. Two clicks to suppress noisy signals (GET /health logs, repetitive health checks) before they reach ingestion and billing. The filter rules export to OTTL (OpenTelemetry Transformation Language), so they remain portable outside the Dash0 ecosystem. This directly addresses one of the most common complaints from Datadog and New Relic users: paying to store data that adds no diagnostic value. (Dash0 Coralogix comparison page; Dash0 pricing page)

PromQL Across All Signals. Dash0 supports full, unmodified PromQL for metrics, logs, and traces. No emulated subset, no proprietary query language layered on top. Teams that already write Prometheus queries can import existing alert rules directly, with access to over 400 pre-built alert templates from open-source knowledge bases. A recent update (May 2026) added the ability to drill down from any PromQL expression directly to the raw telemetry behind it, closing the gap between aggregated views and individual events. (Dash0 homepage; "Everything is Connected" blog post, May 2026)

Dash0 Kubernetes Operator. One-command instrumentation for Kubernetes workloads. The operator auto-injects the OpenTelemetry Collector and instruments supported runtimes without code changes. For teams running Kubernetes at scale, this eliminates the manual per-service instrumentation that makes observability adoption slow. (Dash0 docs; GitHub dash0hq/dash0-operator)

OTelBin (otelbin.io). Dash0's open-source contribution: a web-based tool for editing, visualizing, and validating OpenTelemetry Collector configurations. It has become a standard utility in the OTel community and serves as a significant awareness driver for the Dash0 platform. Referenced in CNCF resources and frequently recommended in OpenTelemetry onboarding guides. (Dash0 GitHub; Dash0 docs)

Configuration-as-Code. Dashboards, alerts, and pipeline rules can be managed through CRDs, Terraform, or CLI, living in version control alongside application code. This prevents the "dashboard rot" common in platforms where configurations are changed manually in the UI and never reflected in source control. Dash0's dashboards are fully compatible with Perses, the CNCF-backed open-source dashboarding standard, making them portable across platforms. (Dash0 Observability as Code page; Dash0 docs)

Cost Forecasting. A built-in integration that breaks down observability spend by service, team, Kubernetes cluster, AWS zone, or any other dimension. Teams can project future costs based on historical ingestion patterns and make data-driven decisions about telemetry volume before the bill arrives. (Dash0 Cost Forecast documentation)

Real Cost

Dash0 uses pure consumption-based pricing with no seat licenses, no base platform charge, and no hidden fees.

Published rates: $0.20 per million metric data points. $0.60 per million spans, span events, or log records. Metric data points and synthetic API check runs are retained for 13 months. Spans, logs, and web events are retained for 30 days. All features are included in a single plan: infrastructure monitoring, APM, distributed tracing, log management, website monitoring, synthetic monitoring, dashboards, alerting, and Agent0. (Dash0 pricing page)

Realistic deployment estimate (50-person engineering team, 20 microservices):

500 million metric data points per month: $100. 800 million spans per month: $480. 400 million log records per month: $240. Total: approximately $820 per month.

A comparable Datadog deployment for the same workload would likely cost between $2,500 and $4,000 per month, driven by per-host infrastructure fees ($15/host), per-host APM fees ($31/host), log ingestion charges ($0.10/GB), indexing costs, and custom metrics surcharges. (Datadog published pricing; Dash0 comparison pages)

How per-data-point compares to per-GB: Dash0's Coralogix comparison page lists Coralogix at $0.42/GB for logs. Dash0 charges per record rather than per byte, so the per-GB equivalent depends on average record size. If a log record averages 500 bytes, one million records equals approximately 0.5 GB, making Dash0's effective rate roughly $1.20/GB for logs. On raw ingestion alone, GB-based pricing can be cheaper. But Dash0's model includes unlimited users and all features (Agent0, Synthetic Monitoring, Website Monitoring), whereas GB-based vendors often add tiered feature costs or seat licenses on top of ingestion. (Dash0 Coralogix comparison page)

Pricing history: Dash0 originally charged a $50 per month base subscription fee that included 100 million metric data points, 25 million spans, and 25 million log records. In February 2025, the base fee was removed entirely, moving to pure consumption. If you send nothing in a billing cycle, you pay nothing. (Dash0 changelog)

What Customers Say

Dash0 has 42 reviews on G2 and a growing base of testimonials on its website and product pages.

What keeps coming up positively: The OpenTelemetry-native architecture is the most frequently praised element. Users report that the seamless navigation from logs to traces to metrics within a single data model eliminates the context-switching that plagues multi-tool observability stacks. The UI speed, particularly the tracing tree and filtering capabilities, is a consistent highlight. Oliver Michels, a DevOps Cloud Architect at Bechtle, describes it directly: "In an age of overly complex tools, we find that Dash0 stands out for its simplicity and speed. With simple pricing, easy integration, amazing filtering capabilities, fast handling of large data volumes, and straightforward alerting with clear error messages, Dash0 makes observability a breeze" (Dash0 homepage, New Relic comparison page). One G2 reviewer called it "a sleek, responsive, and future-proof choice for modern observability" (G2 reviews). Dennis Schulte, CTO of Hayuno AG, noted that "despite being a young company, Dash0 delivers enterprise-grade quality and features, working reliably from day one" (Dash0 distributed tracing page).

What keeps coming up negatively: The platform's youth is the most cited limitation. One G2 reviewer acknowledged that "the tool is still in heavy development" and that "not all convenience features are present yet compared to older, more bloated competitors" (G2 reviews). The breadth of Agent0's capabilities is still expanding. The core SRE and Toil agents are well-regarded, but the Security and Cost agents are earlier in their development. Documentation for advanced custom OpenTelemetry configurations beyond the standard Kubernetes Operator path is still catching up to the product's rapid feature rollout.

Named customers: Zalando, Taco Bell, and The Telegraph are the most prominently referenced, with The Telegraph having a dedicated customer story on Dash0's site. Starling Bank and Porsche were named at the Series A stage. Additional customers visible in the logo bar include Tessl, Duna, Chargetrip, Eventlink, Understory, NO GA, Linearity, and EVgo Fast Charging. All customer-attributed quotes in this article are sourced from Dash0's own website and product pages. No independent case studies, analyst reports, or third-party publications with named operator interviews were found during research. This is consistent with the company's age.

The Competitive Read

Datadog is the market leader. Dash0 competes on pricing predictability (per data point vs. per host plus add-ons), OpenTelemetry-native architecture (no proprietary agent), and the absence of seat-based licensing. Where Datadog leads: feature depth across security (CSPM, SIEM), session replay, a vast integration marketplace, and a decade of enterprise hardening.

Dynatrace dominates large enterprise deployments with its fully automated OneAgent and the Davis AI engine. Dash0 offers lower total cost of ownership and zero vendor lock-in. Where Dynatrace leads: the depth of proprietary auto-instrumentation and vast legacy infrastructure support that Dash0's OTel-first approach cannot yet match.

Grafana Labs shares the open-source DNA. Both bet on open standards. But Grafana requires assembling multiple components (Loki for logs, Tempo for traces, Mimir for metrics), while Dash0 provides a unified SaaS platform with Agent0's autonomous action layer. Where Grafana leads: best-in-class visualization, the largest open-source community in observability, and the flexibility of full self-hosting.

Coralogix is a newer challenger with its proprietary DataPrime query language and infinite retention in customer-owned S3. Dash0 counters with PromQL everywhere (a language teams already know) and Agent0's autonomous capabilities. Where Coralogix leads: the DataPrime query engine is powerful for complex log analytics, and its tiered storage model can be more cost-effective for organizations that need long-term log retention.

New Relic pioneered consumption-based pricing in observability. Dash0 differentiates by eliminating the per-user "tax" that New Relic still charges above its free tier and by building AI agents as the core architecture rather than layering them on top. Where New Relic leads: a generous 100GB/month free tier and a more mature integrated incident response workflow.

The Honest Verdict

Excellent for: Teams building new infrastructure on Kubernetes and OpenTelemetry who want high-fidelity observability from day one without the pricing complexity of incumbents. The Agent0 Toil agent is a genuine time-saver for dashboard and alert generation. For teams already in the Prometheus ecosystem, the unified PromQL experience across all signal types eliminates the friction of learning proprietary query languages. The Lumigo acquisition positions Dash0 as increasingly strong for AWS Lambda and serverless workloads alongside container monitoring.

Breaks at: Dash0 is an observability platform, not a full operations suite. It does not include on-call scheduling, status pages, or native incident management. Teams that need a single vendor for both monitoring and incident response will still need to pair it with PagerDuty, incident.io, or a similar tool. The platform's youth shows in certain niche integrations that decade-old incumbents have built up over time. And while Agent0 is impressive in environments with rich OpenTelemetry instrumentation, its effectiveness degrades in partially instrumented or poorly tagged environments.

Trajectory: The $110M Series B and $1B valuation fund four clear priorities: deepening the Agent0 platform and expanding the autonomous agent library, aggressive US market expansion targeting enterprise teams migrating from Datadog and Dynatrace, completing the Lumigo integration to offer best-in-class AWS Lambda observability by end of 2026, and targeted acquisitions in LLM observability, AI SRE tooling, and AI-focused security. The competitive strategy is clear: use the Migration Agent as the primary sales wedge and the transparent pricing model as the closing argument. If Dash0 executes on the Agent0 vision, the platform evolves from observability into autonomous production operations, where infrastructure monitors, diagnoses, and fixes itself rather than reporting problems and waiting for a human to act.

Set It Up with AI

Prompt 1: Architecture Assessment. "I'm evaluating Dash0 for our observability stack. Our infrastructure is [describe: Kubernetes clusters, cloud provider, number of services, languages used, current monitoring tools]. We currently spend approximately [amount] per month on [current tool]. Generate a migration assessment covering: which services to instrument first, expected telemetry volume estimates, projected Dash0 monthly cost using their published rates ($0.20/M metrics, $0.60/M spans and logs), and a phased rollout plan that runs Dash0 in parallel with our existing tool during evaluation."

Prompt 2: OpenTelemetry Configuration. "Generate an OpenTelemetry Collector configuration for a Kubernetes deployment sending traces, logs, and metrics to Dash0's OTLP endpoint. Include: the Dash0 Kubernetes Operator deployment manifest, resource attribute enrichment (service name, namespace, cluster name, cloud region), a sampling strategy that keeps 100% of error traces while sampling successful traces at 10%, and a pipeline filter that drops health check endpoints (/health, /ready, /live) before export."

Prompt 3: Cost Modeling. "Build a spreadsheet model comparing our observability costs across Dash0, Datadog, and Grafana Cloud for the following workload: [number] hosts, [number] services, [estimated daily span count], [estimated daily log volume], [number] custom metrics. Include per-host fees, ingestion fees, retention costs, and seat licenses where applicable. Factor in Dash0's telemetry spam filter (estimate 15-30% noise reduction) and compare effective per-GB rates across all three platforms."

Prompt 4: Agent0 Evaluation. "Design a two-week evaluation plan for Dash0's Agent0 AI agents in our production environment. Week one: baseline measurement of our current MTTR, dashboard creation time, and alert configuration effort using [current tool]. Week two: deploy Agent0 alongside existing monitoring and measure the same metrics. Include specific test scenarios: inject a latency spike in service [X], trigger an error rate increase in service [Y], and simulate a node resource exhaustion. Document Agent0's triage output quality, response time, and accuracy of root-cause identification compared to manual investigation."

Sources

Independent Third-Party

Customer-Attributed (Dash0-Published)

Company Sources

  • Dash0 Raises $110M Series B at $1B Valuation -- Dash0 blog (Series B detail, "autonomous nervous system for production" framing, investor quotes from Yared/Balderton and Mason/DIG Ventures, Agent0 agent types, use-of-funds, 600+ customers)
  • Dash0 Raises $35 Million Series A -- Dash0 blog (Series A detail, Novakovic "too noisy, too expensive, and too complex" quote, 270 customers in 9 months, Accel and Cherry Ventures commentary, SIFT framework description)
  • Dash0 Acquires Lumigo -- Dash0 blog (Lumigo acquisition rationale, Tel Aviv team, serverless expertise, nearly 600 customers combined, Fortune 500 customer base reference)
  • Lumigo Acquisition FAQ -- Dash0 (pricing translation from Lumigo to Dash0, Lumigo platform maintained through end of 2026, migration timeline)
  • Introducing Agent0 -- Dash0 blog (Agent0 launch November 2025, agent personas, beta phase, "agents should not replace users but support them" philosophy)
  • Everything is Connected: From PromQL to Dashboards and Back -- Dash0 blog (May 2026 PromQL drill-down feature, synthetic metrics, AST-based query analysis)
  • Removing our base subscription fee -- Dash0 changelog (February 2025 pricing change, $50 base fee removed, pure consumption model)
  • Dash0 Pricing -- Dash0 ($0.20/M metrics, $0.60/M spans and logs, 14-day free trial, retention periods, all features included)
  • Observability Cost Out of Control -- Dash0 blog (per-host pricing critique, per-user pricing analysis, per-data-point rationale)
  • Coralogix Alternative -- Dash0 (Coralogix pricing at $0.42/GB logs, DataPrime vs PromQL comparison, spam filter portability)
  • Dash0 GitHub Organization -- GitHub (OTelBin, Kubernetes Operator, Terraform provider, web SDK, agent skills for AI coding assistants, semantic conventions)
  • Dash0 Team -- Dash0 (leadership page: ~20 named team members including Claudia Rosa, Lariel Fernandes, Michele Mancioppi, Andrea Chomiak, Kasper Borg Nissen)

Day 28 of 30. Tomorrow: Copla -- the AI-native compliance platform automating regulatory workflows for teams that cannot afford to get governance wrong.