Meeting Sven from Dash0 at KubeCon EU Amsterdam 2026
At KubeCon EU 2026, I sat down with Sven from Dash0 to talk about one of the hottest topics in the cloud native world: observability, AI, and open standards.
What followed was one of the most honest conversations I have had about the state of observability — where it is broken, where AI actually helps, and why vendor lock-in remains the industry’s dirty secret.
Observability built on open standards
Dash0 is building an observability platform from the ground up on open standards. Not “we support OpenTelemetry as an ingestion option” — genuinely built on open foundations:
- OpenTelemetry for instrumentation and data collection
- PromQL for querying metrics
- Prometheus alerting rules for notifications
- Open dashboard standards for visualization
The goal is straightforward: when an incident happens, the platform should help with root cause analysis so teams can move faster and focus on troubleshooting instead of searching through dashboards.
Sven explained why this matters in practice. When your observability platform uses proprietary query languages, proprietary alerting formats, and proprietary dashboards, every alert rule you write and every dashboard you build becomes an exit cost. You are not paying for observability — you are paying for the privilege of staying.
AI in observability — when it works and when it does not
We had an honest discussion about AI in product development. The hype is everywhere, but Sven was clear about where AI creates real value versus where it is just a checkbox feature.
The problem with bolted-on AI: Just adding an AI agent on top of an existing platform is not enough. A chatbot that queries your metrics is marginally useful at best. For AI to create real value in observability, it needs to be deeply integrated into the product.
Where AI actually helps:
- Onboarding — automatically detecting what is running in your cluster and suggesting instrumentation
- Root cause analysis — correlating signals across traces, metrics, and logs to identify the actual source of an incident
- Issue identification — pattern recognition across high-cardinality data that humans cannot process manually
- Dashboard creation — generating relevant visualizations from natural language descriptions of what you want to monitor
The key insight: AI needs context. An AI that understands your telemetry, your topology, and your deployment patterns can surface insights that would take an engineer hours to find manually. An AI that just wraps a query interface adds almost nothing.
The two types of vendor lock-in
This was one of the most illuminating parts of our conversation. Sven drew a clear distinction between technical lock-in and commercial lock-in:
Technical lock-in is when your data, queries, alerts, and dashboards are stored in proprietary formats. Migrating means rebuilding everything from scratch. Many observability platforms claim to support OpenTelemetry for ingestion but still use proprietary query languages and dashboard formats internally. The data goes in through an open door but gets locked in a proprietary vault.
Commercial lock-in is when long-term contracts, volume commitments, and pricing structures make it economically painful to leave — even if the technical migration is possible.
Sven’s point: many platforms rely on both types simultaneously. They make it technically hard to leave and commercially expensive to try.
Dash0’s approach is deliberately different:
- Consumption-based pricing — pay for what you actually use
- No long-term contracts — customers stay because they want to, not because they are contractually obligated
- Fully open standards — your queries, alerts, and dashboards are portable
The philosophy: create a platform people stay with because they love it, not because they are trapped inside it.
The exploding telemetry problem
We also explored a problem every platform team is dealing with: telemetry volumes are exploding.
The drivers are compounding:
- Kubernetes generates massive amounts of signals — every pod, container, node, and control plane component produces metrics, logs, and events
- High-cardinality data — labels like pod name, container ID, and request path create combinatorial explosions in time series databases
- AI-assisted coding — tools like GitHub Copilot and Claude Code are generating more code faster, which means more services, more endpoints, and more telemetry
- Microservices proliferation — every new service adds another source of metrics, traces, and logs
The result: companies are paying more and more for observability but are not always getting more value in return. The cost curve is growing faster than the insight curve.
This is where consumption-based pricing becomes more than a billing model — it is an incentive alignment. When you only pay for what you use, you are naturally incentivized to optimize your telemetry pipeline, filter noise early, and focus on signals that matter.
Why this matters for platform teams
If you are building an internal developer platform or running Kubernetes at scale, your observability stack is one of the most critical and expensive components. The choices you make today will determine:
- How fast you can respond to incidents — minutes or hours?
- How much you pay as your cluster count and service count grow
- How portable your investment is — can you switch vendors without rebuilding everything?
- How useful AI features will be — bolted-on versus deeply integrated
Dash0’s bet is that the future belongs to platforms built on open standards with AI deeply woven into the product — not platforms that trap you with proprietary formats and add AI as a marketing feature.
Key takeaways
- Open standards are not optional — if your queries, alerts, and dashboards are not portable, you are locked in
- AI needs deep integration — bolted-on chatbots do not replace genuine product intelligence
- Technical lock-in and commercial lock-in compound — watch for both
- Telemetry volumes are exploding — consumption-based pricing aligns incentives
- The best retention strategy is a great product — not contracts and exit costs
Big thanks to Sven for joining me at KubeCon EU Amsterdam 2026.
