DOP 362: Feature Flags vs Canary Deployments

Episode 362

Show Notes

#362: Feature flags or canary deployments - do you need both? Viktor puts it to Alex Casalboni from Unleash, who says he argues about this with his colleagues roughly every day, and the answer lands clean. Switching a hostname, a database, an API vendor? That is infrastructure, nothing to do with who the user is, so keep your canaries and your blue-green. But a canary switches one thing at a time. Try running three A/B tests and ten behavioral changes through it and the whole approach buckles. Anything that needs to know who the user is belongs in a flag. Different layers of the stack, different tools, and most teams will end up with both whether they planned to or not.

Back up, though, because there is a new word attached to all of this. FeatureOps. There is a manifesto and everything, sitting at featureops.io, reading a lot like someone nailed 95 theses about feature flags to a door. Real discipline, or marketing wrapper? Alex gets about ten seconds of pleasantries before he has to answer for the word. His defense is narrower than the name suggests, and better for it: every ops discipline we have gets you to the deployment and then waves goodbye. Something breaks, you go around the whole loop again - hotfix, pipeline, 20 or 30 or 60 minutes, fingers crossed. FeatureOps is the claim that the same principles apply after the code is already running. Runtime control. Alex says enterprise customers routinely have a 12 to 24-hour round trip between finding a problem and getting the fix live. Even for a hotfix.

Viktor is not letting the seconds claim through unchallenged. If it takes you a day to notice and two seconds to flip, that is a day and two seconds - so stop measuring from the convenient starting line. Alex concedes the framing and then goes somewhere better with it: the bottleneck was never the clicking. It is the humans and the bureaucracy in between. Which is why Unleash is pushing impact metrics, where the SDK sends error rates back and the system kills the feature itself, no human in the loop. Then Darin calls BS on immutable event log, because there is no such thing as immutable data, and Alex takes the hit cleanly - fair, it is append-only with locked-down keys, not magic.

Nobody puts this part on a landing page. Flag evaluation has an input, not just a true/false output, and that input is user context - which means an external API call is not just latency, it is your PII leaving the perimeter. A compliance problem hiding inside a performance decision. And the flag graveyard is worse than you think: companies create roughly ten flags for every one they clean up, and Alex has a customer whose oldest flag dates to 2012. His fix is an MCP server that opens the cleanup PR for you when you mark a release complete. Best line of the day, on whether flags complicate your code: everything complicates your code, and the best way to not complicate your code is to not code.

Frequently Asked Questions

When should you use feature flags instead of canary deployments?

Alex Casalboni of Unleash draws the line on DevOps Paradox episode 362 at whether the switch needs application-level knowledge. Swapping a database, an API vendor, or a hostname stays at the infrastructure level, where canary and blue-green deployments fit well. Anything depending on user context, or where you want three A/B tests and ten behaviours running at once, gets unmanageable as a canary. Teams commonly use both at different layers.

What is FeatureOps?

Alex Casalboni describes it on DevOps Paradox episode 362 as applying DevOps principles after the deployment rather than only up to it. Most tooling helps until code reaches production, and after that a problem means another hotfix and another pipeline run. FeatureOps is about runtime control: changing application behaviour in production in seconds to shrink the blast radius of an incident, instead of waiting on a release cycle.

Is it still a feature flag if changing it requires a redeploy?

Alex Casalboni’s answer on DevOps Paradox episode 362 is no, and he presents it as Unleash’s opinionated position. If flipping the flag needs a full CI/CD run and a redeployment, what you have is closer to an environment variable read once at startup. He notes many enterprises live with a twelve to twenty-four hour round trip between spotting a problem and getting a hotfix into production.

How do you stop feature flags turning into technical debt?

Alex Casalboni cites research on DevOps Paradox episode 362 showing an order of magnitude gap between the number of flags companies create each year and the number they clean up. One customer’s oldest flag dated from 2012. His advice is to put cleanup into the definition of done, and he describes wiring an MCP server into a GitHub workflow so marking a flag complete opens a cleanup pull request automatically.

Should feature flag evaluation happen over an API call?

Alex Casalboni argues against it on DevOps Paradox episode 362 for two reasons. A round trip rarely costs less than ten or twenty milliseconds, and rendering a single page may check ten flags. The second reason gets less attention: evaluating a flag needs user context, which can include personal data, so a remote call sends that outside your perimeter. Local evaluation keeps both the latency and the data at home.

Do you need to test every combination of your feature flags?

Alex Casalboni says on DevOps Paradox episode 362 that combinatorially it looks impossible, but in practice it is not. Most flags never touch the same code path, and many only ever move from off to on before being removed. His suggestion is to start from the current production state and test the major branches from there, so ten flags means roughly five or six cases rather than a hundred.

What is the DevOps Paradox podcast?

DevOps Paradox is a weekly podcast co-hosted by Darin Pope and Viktor Farcic, covering DevOps, platform engineering, and modern software delivery. Episode 362 features Alex Casalboni of Unleash on FeatureOps, where feature flags fit alongside canary deployments, and how to keep flags from piling up as technical debt. Every episode page carries audio, video, and a full transcript.

Share and Download

Guests

Alex Casalboni

Alex Casalboni

Alex is a software engineer, cloud architect, and developer advocate with more than 15 years of hands-on experience in building products and supporting technical communities.

He spent six years at AWS, where he combined deep technical expertise with storytelling to help builders understand and adopt modern cloud architectures.

Throughout his career, Alex has worked across open source, startups, and large-scale cloud platforms, contributing as a speaker, developer, blogger, podcaster, and technical educator - turning complex systems into clear mental models that engineers and decision-makers can use in real-world environments.

Today at Unleash, Alex helps teams adopt FeatureOps and enterprise resiliency best practices. He’s driven by one simple goal: helping builders ship better software, faster, and with confidence.

Hosts

Viktor Farcic

Viktor Farcic

Viktor Farcic is a member of the Google Developer Experts and Docker Captains groups, and published author.

His big passions are DevOps, Containers, Kubernetes, Microservices, Continuous Integration, Delivery and Deployment (CI/CD) and Test-Driven Development (TDD).

He often speaks at community gatherings and conferences.

He has published DevOps Paradox and Test-Driven Java Development.

His random thoughts and tutorials can be found in his blog The DevOps Toolkit.