According to recent theCUBE Research analysis, over 20% of enterprises now deploy feature flags as a core part of their release strategy, yet fewer than 10% can confidently tie those flags to real-time production behavior or business outcomes. As software delivery accelerates, driven by AI-assisted development, continuous deployment, and smaller batch releases, the gap between shipping code and understanding its impact is widening.
In this episode of AppDevANGLE, recorded live at Dynatrace Perform 2026, I spoke with Michael Beemer, Senior Product Manager at Dynatrace, and Andrew Norris, Principal Product Manager at Dynatrace and former CEO of DevCycle, about how feature management is evolving from a developer convenience into a first-class control layer for modern software delivery.
Our conversation explored why feature flags are becoming essential in AI-driven SDLCs, how observability closes the safety gap created by faster releases, and what it means to move from passive monitoring toward active, feature-level control in production systems.
Closing the Gap Between Feature Flags and Observability
Feature flags have long been a developer-native mechanism for reducing release risk. They allow teams to deploy code safely, expose functionality selectively, and react quickly when something goes wrong. But in most enterprises, feature management has remained disconnected from observability data, forcing teams to make rollout decisions with incomplete information.
Norris framed this challenge as one of visibility rather than adoption. As he put it, “We hear again and again that teams are shipping with feature flags, but they don’t really have a good understanding of what’s running where, which flags are active, and whether it’s actually safe to expand a rollout.”
By integrating DevCycle directly into the Dynatrace ecosystem, those decisions can now be informed by live telemetry (logs, traces, errors, and session replay) rather than intuition. Norris described this moment as giving teams a “thumbs up” signal: “It’s that confidence to say, okay, we can move from internal users to external customers now.”
This integration effectively turns observability into a release confidence engine, replacing guesswork with data-backed signals.
From Service-Level Monitoring to Feature-Level Insight
Traditional observability platforms excel at answering service-level questions: Is latency up? Are error rates spiking? Is infrastructure healthy? What they struggle to answer is why those changes occurred and which decision triggered them.
Beemer emphasized that feature flags represent explicit developer intent. “Feature flags basically start and end with developers,” he explained. “They’re saying this code path matters. This is something important to the business.”
By aligning those signals with observability data, Dynatrace can shift monitoring away from generalized system health and toward what actually drives customer and business outcomes. Instead of correlating incidents after the fact, teams can see the impact of a specific feature flag on performance and user experience as it happens.
This reframes observability from a reactive discipline into a decision-support system embedded directly in the release process.
De-Risking High-Velocity and Agentic Development
The importance of this convergence becomes even clearer in the context of AI-assisted and agentic development. As teams rely more heavily on AI tools to generate and modify code, production behavior becomes harder to predict in advance.
Norris pointed out that feature flags are uniquely suited to this reality: “With non-deterministic code, production is often the only place where you can really see how it’s going to behave.” Feature flags allow teams to ship quickly while still controlling exposure, validating behavior with real users, and rolling back instantly if needed.
Rather than slowing teams down, feature flags paired with observability enable faster iteration with lower risk, which is a critical tradeoff as release velocity continues to increase and agentic systems become more common.
Connecting Release Decisions to Business Outcomes
Beyond technical assurance, DevCycle also brings experimentation and A/B testing into the same control loop. This can give teams the ability to evaluate not just whether a feature is stable, but whether it is delivering measurable business value.
Norris highlighted this shift clearly: “It’s not just about technical impact anymore. You can tie feature releases directly to business metrics—things like subscriptions, engagement, or conversion.”
For executive stakeholders, this changes the conversation. Release decisions are no longer framed purely around uptime or error rates; they become business decisions grounded in real outcomes.
Managing Feature Flags as a Lifecycle, Not a One-Time Action
Feature flags introduce flexibility, but unmanaged, they can also introduce long-term complexity. Over time, enterprises may accumulate hundreds or thousands of flags, increasing cognitive load and operational risk.
Norris addressed this concern directly, noting that DevCycle’s name reflects its philosophy: “We believe in full lifecycle feature flagging.” That lifecycle includes identifying when a flag has run its course and safely removing it, preventing feature management from becoming another source of technical debt.
This approach aligns with a broader expectation emerging in platform engineering: modern delivery tooling must help manage its own operational footprint, not quietly expand it.
Analyst Take
Dynatrace’s integration of feature management into its observability platform signals a meaningful evolution in how software delivery is governed at scale. Observability is no longer just about understanding systems after something breaks; it is becoming a control layer for deciding what runs, where, and for whom.
For application development and platform teams, this convergence matters because it brings developers into observability workflows as first-class participants, not downstream consumers. It also provides a practical mechanism for managing risk in high-velocity, AI-driven delivery environments without reverting to slower release models.
Feature management, in this context, is no longer a niche developer tool. It is emerging as a foundational component of the modern delivery control plane that connects developer intent, operational reality, and business outcomes in real time.
If this direction holds, the next phase of observability will be defined less by what platforms can see, and more by how effectively they help teams act.
