OpenTelemetry: Auto-Instrumentation not Blind-Instrumentation

Observability is no longer optional in cloud-native systems but "turn it on and hope" is not a strategy. OpenTelemetry autoinstrumentation promises instant visibility, yet in practice it can quietly introduce cost, performance, and security risks when used without intent.

This talk challenges the idea that more telemetry automatically means better observability. Using a real production example as context, we'll show how autoinstrumentation can surface far more internal behavior than teams expect, creating noise instead of insight. We'll examine what goes wrong, why defaults are dangerous, and how easily good intentions can backfire at scale.

We'll also be clear about the upside: when manual instrumentation isn't feasible, autoinstrumentation is still better than having no telemetry at all. The key is knowing where it helps, where it hurts, and how to use it deliberately.

Why One-Size-Fits-All MCPs Don’t Work

MCPs work best when they are designed for a specific problem. We tried building a single MCP to serve our entire observability stack, and it failed. Without specific tools, the MCP became too generic for agents to be effective. This talk covers what went wrong and why MCPs should be purpose-built around concrete workflows instead of trying to do everything at once.

Freedom Through Boundaries: Building Configurations That Age Well

Just a Helm Chart. It always starts simple. A few options, a couple of flags, and the best intentions. Then the requests start coming in. “Can we also support this?” “What if someone needs that?” Before long, the config file looks like a museum of past decisions, full of toggles nobody remembers adding and an ever-increasing queue of new feature requests.

After maintaining one of those for too long, I learned that flexibility is not about offering every possible switch. It is about choosing the right ones. Real freedom comes from clear boundaries, good defaults, and the courage to remove things that no longer make sense, or just say no.

We will explore what happens when configuration grows too much, how to make it healthy again, and how to better communicate decisions to users.

Talk combines philosophy and practical lessons. Focuses on designing configurable packages, planning deprecations, and empowering users while keeping complexity manageable

OpenTelemetry: You Can’t YAML Your Way Out of This

Adopting OpenTelemetry might look easy at first, change some YAML, deploy a collector and you're done, but once you operate as scale your fears become reality, defaults are no longer applicable, integrations no longer work and configuration alone will not get you where you want to be.

I will present how we developed an observability stack around OpenTelemetry, the challenges we faced and how we overcame them by building custom components.

This talk is not only about OpenTelemetry, it's about the importance of understanding the tools you use in production. Open projects like OpenTelemetry don't exist to perfectly fit every use case out of the box, treating them as drop in solutions leads to frustration while treating them as the foundation of something bigger unlocks their true power.