Your Open Source Standard Is Just Another Lock-In

Open source standards promise freedom, vendor neutrality, interoperability and no single company pulling the strings.
But swap one proprietary API for OpenTelemetry, OpenFeature, or Kubernetes - and ask yourself honestly: how easy is it to leave?
In this session, two independent practitioners take the stage on opposite sides of that question. One argues the lock-in is real - migration costs, governance slowdowns, specs shaped by committee rather than conviction. The other argues the opposite: that community-owned consensus is exactly what makes innovation possible, ecosystems diverse, and startups viable without building their own moat.
No vendor slides. No easy answers. Just the argument your architecture deserves.

The Software Organism: Designing for Evolution

We don't build software anymore. We grow it — poorly, slowly, and mostly by accident.

Every pull request is a mutation. Every deployment is a generation. Every incident is selection pressure. We've been running evolution without knowing it, with humans as the bottleneck in a feedback loop that should close in milliseconds.

Living organisms solved this differently. They separated mutation from adaptation. They built nervous systems — layers that sense, layers that act, layers that maintain stability without conscious intervention. And they developed proprioception — the organism's awareness of its own state. Where its limbs are. What's alive and what isn't.
Your business doesn't have that. You have dashboards. You have flag states nobody queries. You have business outcomes disconnected from the behaviors that caused them.

This talk doesn't show a working system. It asks whether the primitives we've already built — observability, feature flags, platform engineering, the track API — are quietly assembling themselves into something we haven't named yet. And whether we're designing toward it or stumbling into it.

Polyglot Testing Unleashed: How OpenFeature's Reference Implementation Validates Across Languages

How do you ensure a cloud-native reference implementation behaves consistently across Python, Go, .NET, JavaScript, Java, and beyond? Discover how the flagd-testbed project validates both the core flagd service and its language-specific integrations through a single, unified test suite. Leveraging Gherkin specifications as behavioral contracts, Testcontainers for real-world integration testing, and Renovate for automated testbed synchronization, this approach delivers reliable feature flagging across diverse environments. Reusable Gherkin steps and clear step mapping streamline bug identification, instantly pinpointing whether failures stem from the core service, language implementations, or integration layers—catching subtle bugs before they reach production. Learn practical strategies for scalable polyglot testing, reusable test specifications, and building infrastructure that grows with your ecosystem. Join us for actionable insights and real-world lessons from the flagd testbed!

18 Bluetooth Controllers Walk Into a Bar: Observability & Runtime Configuration with CNCF Tools

What happens when your "distributed system" is 18 PlayStation Move controllers on Bluetooth? Observability challenges web developers never face.

JoustMania is an open-source party game where players jostle motion controllers. Complex execution: multiple Bluetooth adapters, battery-powered devices, sensors at 100Hz. When a player complains their controller "felt different" - how do you debug it?
Challenges:
- Sampling data from 18 controllers without overwhelming telemetry
- Correlating hardware events with gameplay
- Managing high-cardinality data
- Debugging problems at 2 AM conventions

Solutions:
- Context-aware flags responding to battery, skill, system load
- Intelligent sampling capturing critical events, dropping noise
- Trace correlation between hardware and game logic
- Using OpenTelemetry to prove games are "rigged" (or not)

Demo: Change behavior via GitHub-synced flags, show real-time controller telemetry, reveal emergent behavior in physical systems.

OpenFeature’s Positive Impact on Confidence at Dynatrace

At Dynatrace, feature flags have been integral to our workflows for years. However, our homegrown solution has increasingly become a fragmented collection of flags rather than a comprehensive management tool. This has led to challenges such as unclear use cases, legacy flags with unknown or unintended uses, and complexity compounded by team transitions and shifting assignments.
To address these issues, we embraced OpenFeature to standardize and enhance feature flag observability—not just for our benefit but for the broader developer community. By integrating OpenFeature with OpenTelemetry, our Site Reliability Engineers (SREs) now have actionable insights, enabling them to confidently assess potential impacts and side effects across our systems.
Join us as we share our journey with OpenFeature at Dynatrace and how it’s transforming the way we manage feature flags.

Fun with Flags: How OpenFeature Solves Your Feature Flag Headaches

Feature flags have revolutionized the software delivery lifecycle, enabling teams to decouple releases from deployments and create a more agile development process. They're often hailed as one of the key practices in modern software development—at least in theory.

However, as systems grow in complexity, so do the challenges associated with feature flagging. From supporting multiple languages and managing targeted evaluations to avoiding vendor lock-in and safely decommissioning obsolete code, what initially seems like a straightforward problem can quickly become daunting.

The OpenFeature community is tackling these challenges head-on by providing vendor-agnostic SDKs and a suite of powerful tools designed to simplify the feature flagging experience. Join me as we explore the common pitfalls of feature flagging and discover how OpenFeature can help bring the fun back into this critical aspect of software development.

Target audience: Everyone within the SDLC can profit from feature flags, basic overview, entry into feature flagging