CNCF-hosted Co-located Events Europe 2025

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.

As cloud-native systems scale, managing application features dynamically without disrupting services is a cornerstone of modern software delivery. In this talk, we'll delve into the integration of Kubernetes with OpenFeature, a powerful open standard for feature flag management, to bridge application logic with infrastructure orchestration.

The session will explore Kubernetes-native resources like ConfigMaps, Secrets, and external flag services to store and manage feature configs, enabling real-time toggling without service restarts. Combined with Kubernetes' rolling updates, it ensures rapid recovery from critical issues, safeguarding system stability. This integration redefines how developers roll out features, offering unprecedented control for A/B testing, and canary deployments.

By combining K8s' orchestration power and OpenFeature’s runtime control, this approach not only redefines feature management but also aligns with the future of scalable, adaptive cloud-native ecosystems.

Hooks in OpenFeature are a powerful mechanism for adding custom behavior at well-defined points in the feature flag evaluation life cycle.

They allow developers to automate repetitive tasks and streamline workflows, such as validating resolved flag values, enriching evaluation context, logging, telemetry, and tracking feature usage.

In this session, we’ll explore how hooks work, their role in the evaluation life cycle, and the types of behavior they can implement. Designed for developers seeking clean and efficient feature flagging practices, this talk provides insights into how OpenFeature hooks simplify and enhance flag evaluation without cluttering your application logic.

In the end, attendees will learn how to implement OpenFeature Hooks in their projects.

Based on two decades of deploying and rolling back software and seven years of helping customers achieve their CD goals, this session debunks myths about canary deployments. While they are viewed as essential to progressive delivery, they are far from a universal solution.

Canary deployments rarely uncover last-minute issues in strong CI/CD pipelines. They demand significant investment in deployment processes, database compatibility, and rollback strategies—often outweighing the benefits. Most importantly, they lack precision, requiring workarounds for targeting subsets of users.

This session shows that OpenFeature meets progressive delivery goals without overhauling your build and deployment processes. It allows you to separate deploying new versions from releasing functionality. Rollbacks require a simple toggle instead of redirecting to an old version. With segmentation, OpenFeature enables targeted rollouts to specific users or groups, gathering feedback over time.

Many of us are familiar with the challenges of distributed computing that result from the properties of real networks, such as unexpected latencies, dropped connections or dynamic network topologies. These challenges also need to be considered when trying to ensure consistent and reliable feature flag evaluations across multiple downstream services in distributed systems.

We will introduce an exemplary distributed systems architecture and illustrate and discuss the potential issues that can arise when attempting to implement feature flag evaluations under various consistency requirements. We will then present several potential solutions that address these issues discussing their pros and cons, and evaluate how well they satisfy the given requirements.

Finally, we will examine how OpenFeature can support the implementation of these potential solutions and provide insights into the current state of discussion on this topic within the project.

Are your deployments stuck in the past? Fear no more! Feature Flags are here to bring agility, control, and creativity to your Kubernetes workloads. In this fun and insightful talk, we’ll explore how feature flags can enable dynamic, fearless experiments and scalable deployments in modern applications.

This talk will show you the path to smoother, smarter deployments.
We'll cover how to:
1. Dive into OpenFeature, and see how it pairs perfectly with Kubernetes to orchestrate deployments.
2. Integrate feature flags in Kubernetes to leverage tools like ArgoCD, Flagger, and Prometheus,
3. Real-world stories of flagging triumphs (and a few hiccups)

This talk will cover how the Multi-Provider for OpenFeature works, enabling seamless integration of multiple feature flag providers within a single application.

We will cover use cases such as hybrid environments where teams leverage different providers for specific projects or systems, gradual migrations from one provider to another to minimize deployment risks, and improving interoperability by integrating in-house solutions with external providers.

We will explore how OpenFeature’s evolving ecosystem drives interoperability, improves developer experience, and fosters vendor-neutral feature flagging.

As feature flags move from simple toggles to core infrastructure, engineers face complex technical challenges that aren't covered in basic tutorials. This technical session dives deep into 3 critical problems in feature flag architecture at scale: maintaining consistency across regional deployments, handling circular dependencies between flags, and managing flag evaluation performance under heavy load.

The presentation walks through specific architectural patterns, including:

* Implementing consistent hashing for user targeting across distributed services
* Using dependency graphs to detect and prevent circular feature flag references
* Building efficient caching layers that handle rapid flag updates without sacrificing evaluation performance
* Managing flag cleanup through automated detection of stale references

Each pattern will be demonstrated with code examples showing both naive implementations and production-ready solutions.

Running 20+ concurrent experiments across your product can sound like playing roulette with production. Feature combinations grow exponentially (2^20 possible states!), while the A/B testing may sound more like A/Z chaos. 

Join this lightening talk as we talk about how to develop a feature experimentation framework using OpenFeature that prioritizes experiments based on business impact, cut the number of failed experiments by 70% while increasing successful feature adoption by 45%.