Last updated: September 19, 2025
Code Red Newsletter #16
Hi there,
If you’ve been around Kubernetes long enough, you know the drill: everything becomes YAML eventually. Deployments, RBAC rules, Ingresses - if it runs in the cluster, there’s probably a manifest for it. Observability, though? That’s often the odd one out. Dashboards live in a UI, alerts get clicked together, and suddenly staging and production don’t even look like the same system.
That’s where Observability as Code comes in. By managing your telemetry resources declaratively, you get consistency, version control, and GitOps workflows - the same engineering discipline we already apply to infrastructure.
In focus: Observability as Code
At Dash0, we want to provide you with the same control for observability that you already expect from the rest of your platform. The Dash0 Operator makes this possible with CRDs that let you declare monitoring the same way you declare services and deployments. Auto-instrumentation, log pipelines, dashboards, and alerting rules all become reproducible, reviewable, and easy to roll out across clusters.
The value goes beyond neat YAML. It’s about fewer drift issues, faster onboarding, golden paths for monitoring, and less time rebuilding dashboards by hand.
To show what this looks like in practice, we’ve collected a set of resources that highlight different ways observability is becoming truly declarative - from Terraform integrations to dashboard composition and even lessons from the data pipeline world.
Manage Views & Rules via Terraform
Prefer HCL to YAML? The updated Dash0 Terraform Provider now supports managing check rules and custom views. That means your alerting and dashboards can live alongside the rest of your infra-as-code setup, fully synchronized with Dash0. No more manual clicks, just declarative clarity.
Introduction to Perses
Saiyam Pathak introduces Perses, the CNCF project bringing open dashboards to Prometheus and beyond. In this talk, he walks through how Perses works under the hood - and even shows how to write dashboards in Golang. A great entry point if you want to understand why Perses matters in the “dashboards as code” story.
Composable Dashboards: Lessons from Perses
Dashboards don’t have to be snowflakes. The Perses community is doubling down on reusable, composable dashboards. Think components you can plug together, share across teams, and keep versioned like any other code. Dash0 supports Perses CRDs out of the box, so your dashboards stay portable - no matter the backend.
Code RED Podcast: Data Observability at the Source
In this episode, Ido Bronstein (Upriver) joins Mirko Novakovic to talk about what happens when your upstream data is messy - and how to monitor in a future full of AI-driven systems. From detecting bad data early to making observability part of the data pipeline itself, it’s a conversation that connects directly to where our telemetry is headed.
Choice cuts
Because every observability stack deserves a side dish.
How to Name Your Metrics
Juraci Paixão Kröhling continues his “How to” series with a deep dive into metric naming. OpenTelemetry’s guidelines aren’t just theory - they’re the foundation for consistency across signals. Get them wrong, and your dashboards turn into chaos. Get them right, and your queries actually make sense.
How to Contribute to OpenTelemetry
Want to give back but don’t know where to start? Marylia Gutierrez lays out a roadmap for contributions, from docs to SIGs to code. A must-read for anyone looking to go from user to contributor.
The EU Data Act Just Killed Long SaaS Contracts
A sharp analysis of what the Data Act means for vendors and buyers. Hint: multi-year lock-ins are about to become history, and portability is the new default.
Node.js GCP Resource Detection
If you’ve struggled with Node.js resource detection, good news: the GCP resource detector has now been merged upstream in OpenTelemetry. That means it’s part of Node.js auto-instrumentation by default. I’ve personally pushed a bit for this to happen, so it’s awesome to see it land.
Final Thoughts
Observability has often lagged behind the rest of the platform when it comes to automation and consistency. But with operators, Terraform, and open projects like Perses, that’s changing fast. By treating telemetry as code, we’re moving toward golden paths, reproducible environments, and monitoring that scales with the platform itself.
That’s the thread connecting everything in this issue: from managing check rules in Terraform to composing dashboards with Perses, from upstream contributions in OpenTelemetry to keeping bad data out at the source. Observability is no longer a separate system - it’s part of the platform.
And if you missed it, the Observability for Platform Engineering free course we highlighted in the previous issue is already a hit. It’s free, and it touches on many of the same topics from this newsletter - operators, automation, and making observability part of your platform. Sign up here: Observability for Platform Engineering.
We’ll be back in two weeks with more signals, stories, and maybe a few YAML jokes (no promises). Until then: commit your dashboards, version your check rules, and let the operator do the heavy lifting.
Kasper, out.
