Feature Flag Architecture: Rollouts & Kill Switches

Q: What is the difference between deploying and releasing?

Deploying is putting code into the production environment; releasing is exposing its behavior to users — and conflating them is why so many deploys feel dangerous. Without feature flags the two are the same event: the moment code ships, users get the new behavior, so every deploy carries full release risk and every rollback means reverting and rebuilding under pressure. Feature flags insert a seam between them. Code deploys to production dark — present in the running system but inert behind a condition that evaluates to off — so the deploy is low-risk (nothing changed for users) and can happen continuously. The release becomes a separate, smaller act: flip the flag for internal users, then 1% of traffic, then cohorts, then everyone, watching metrics at each step, with reversal a config change measured in minutes rather than a pipeline run. This separation unlocks the practices modern delivery depends on: trunk-based development (merge incomplete work safely because it is flagged off), continuous deployment (ship many times a day without releasing each time), progressive delivery (meter exposure by percentage or cohort), and instant rollback (flip off, no rebuild). The mental shift is that "it is in production" and "users have it" become independent facts you control separately — which is exactly the calm a high-stakes launch needs, because the reverse gear is a config toggle you have already tested, not an emergency deploy you are attempting for the first time while the graphs are red.

Q: What are the different types of feature flags?

Four types, distinguished by how long they live and how often they flip — and the type dictates the engineering, so misclassifying one is a design error. Release toggles are short-lived: they gate a new feature during development and rollout, flip once in the forward direction as the feature reaches 100%, and must be deleted within a sprint of full release — leaving them is the primary source of flag debt. Experiment toggles power A/B tests: they flip per user by bucket, live for the duration of the experiment (weeks), and are removed once the winner is chosen; they demand sticky per-user bucketing and statistical rigor. Ops toggles, including kill switches, are long-lived by design: they let operators disable expensive or fragile behavior under load or during a dependency outage, flip rarely but in anger, and must evaluate at runtime because their entire value is flipping fast — a kill switch behind a rebuild is not a kill switch. Permission toggles are also long-lived but flip per user or plan: they gate features by entitlement (enterprise-only SSO, beta access), overlap with authorization, and must enforce server-side. The practical consequence of the taxonomy: a release toggle can be a build-time constant activated by redeploy, but an ops kill switch needs runtime evaluation and a deliberately chosen failure default; treating all flags as one kind is how teams end up with kill switches they cannot flip quickly and release toggles they never remove.

Q: What is flag debt and why is it dangerous?

Flag debt is the accumulated cost of feature flags that outlived their purpose — release toggles left at 100%, dead experiment flags, abandoned toggles nobody owns — and its danger is combinatorial, not linear. Every live flag doubles the theoretical state space: 10 flags mean 1,024 possible combinations of on/off, 20 mean a million, 40 mean a trillion. Your test suite exercises a tiny handful of those combinations — usually all-on or all-off — while production traffic hits combinations no one has ever tested, because real users land in different buckets across many flags simultaneously. Beyond the untested-state explosion, stale flags impose steady costs: every reader of the code must reason about branches that will never flip again, refactoring must preserve dead paths, and each dormant toggle is a loaded mechanism waiting to be misfired or repurposed. The canonical catastrophe is Knight Capital in 2012: a deployment reused an old feature flag whose meaning had changed, one server ran stale code, the flag activated dormant logic, and the firm lost roughly $440 million in 45 minutes — a flag-debt incident in its purest form. The discipline that prevents it is mechanical rather than clever: assign every flag an owner and an expiry date at creation, run monthly audits that flag any toggle serving 100% or 0% for 30 days as a deletion candidate, test the off-state of every release flag and both sides of every kill switch, and enforce one-flag-one-meaning so a toggle is never repurposed. The goal is keeping the live-flag count low enough that the state space stays within reach of your tests.

Q: How do progressive rollouts and canary releases work with feature flags?

A progressive rollout uses a flag to expose new behavior to a growing fraction of users while watching whether their metrics diverge from a control group, so problems surface at 1% instead of 100%. The mechanics: the flag SDK evaluates a targeting rule that assigns each user to a variant based on a percentage bucket, and the operator widens the percentage in stages. The playbook that works: deploy dark and verify the off-state is unchanged (this is also your rollback target); enable for internal users first to catch the obvious breakage cheaply; canary to 1-5% of real traffic with dashboards comparing the exposed cohort against control on the metrics that matter (error rate, latency, conversion, whatever the feature could hurt); widen to larger cohorts only while those metrics hold; reach 100%; then delete the flag and the now-dead control branch. The non-negotiable technical requirement is sticky bucketing: the same user must land in the same variant on every request and across every service, achieved by hashing a stable identifier (user ID, account ID — never session ID or a random per-request value) together with the flag name. Without stickiness, a user flips between new and old on refresh, which both ruins experiment validity and generates confusing bug reports. Canary via flags is strictly better than deploy-based canary for behavior changes because the rollback is a config flip rather than a redeploy, and the same discipline extends naturally to schema migrations, prompt versions, and model swaps — anything where you want exposure metered and reversal instant.

Q: What should happen when the feature flag service is unavailable?

Every flag must resolve to a predetermined safe default, chosen per flag in advance — because when the flag service is unreachable, each evaluation still returns something, and if nobody decided what, the outage decides for you at the worst possible moment. The layered defense that production systems use: the flag SDK evaluates in-process against a locally cached copy of the rules, so a brief flag-service outage changes nothing (the SDK keeps serving the last-known rules it streamed or polled); if the SDK has no cached rules at all (cold start during an outage), it falls back to hardcoded defaults compiled into the application. The design work is choosing those hardcoded defaults deliberately by flag type. A release toggle for an unfinished feature defaults off — a flag-service outage must never force-launch half-built behavior (we have audited a checkout flow whose flag defaulted on, meaning a flag outage would have exposed an incomplete payment path to every user). A kill switch usually defaults to the feature staying on — the switch failing should not fire the gun, because the common case is the feature working and the flag service having a bad day. A permission toggle defaults to the least privilege — deny access rather than grant it when uncertain. The anti-pattern is evaluating flags by calling the flag service synchronously per request with no cache and no default: that turns the flag system, which exists to reduce risk, into a new single point of failure on every code path it touches. Local evaluation plus explicit per-flag defaults makes the flag layer strictly safer than the code it gates.

Q: Should I build feature flags myself or use LaunchDarkly or Unleash?

Match the tool to the flag types you actually have, and graduate rather than over-buy. For a handful of release toggles on a server-rendered application, environment variables or a simple config table are genuinely sufficient — flipping a release toggle by redeploy is an acceptable activation path since release toggles flip once, forward, on a schedule you control (this is a common and correct starting point, and it is exactly what many dark launches use). You outgrow env vars the moment you need any of: percentage-based rollouts, per-user targeting, sticky bucketing across services, an audit log of who flipped what when, or runtime flips for kill switches that cannot wait for a rebuild. At that point the choice is self-hosted versus managed. Unleash (open source, self-hostable) keeps flag data and evaluation inside your infrastructure, which matters for data-residency-sensitive shops and keeps costs predictable; LaunchDarkly and similar managed platforms offer richer targeting, experimentation, and analytics with less operational burden, at a per-seat or per-context cost. Across either choice, adopt OpenFeature — the CNCF vendor-neutral SDK specification — as your application-facing interface, so your code depends on a standard API rather than a specific vendor and you can change providers without touching call sites. Whichever you pick, the evaluation-side disciplines are identical and non-negotiable: in-process evaluation against cached rules, sticky bucketing on stable identifiers, explicit safe defaults, and lifecycle enforcement (owners, expiry, stale-flag audits) — the tool provides the plumbing, but the discipline is what prevents the debt.

Q: Are build-time and runtime feature flags different?

Fundamentally, and confusing them is a recurring incident cause. A build-time flag is resolved when the application is compiled or bundled: its value is baked into the artifact, so changing it requires a new build and deploy. In modern frontends this is the NEXT_PUBLIC_ family and equivalents — values inlined into the JavaScript bundle at compile time, visible in the shipped code, and immutable until the next build. A runtime flag is resolved while the application is running, per request or per evaluation, by an SDK reading current rules — so it flips in seconds without a deploy. Both are legitimate, but they fit different flag types. Build-time flags are acceptable for release toggles, where the planned activation path is a redeploy anyway and the flag flips once, forward; they are also unavoidable for anything that must be tree-shaken out of a client bundle. They are disqualifying for kill switches and ops toggles, whose entire value is flipping fast under pressure — discovering mid-incident that your "kill switch" is a NEXT_PUBLIC_ constant behind a 15-minute build pipeline converts a two-minute rollback into a twenty-minute one, which is the difference between a blip and an outage in the postmortem. A useful house rule: static build-time flags may gate release toggles where a rebuild is the intended mechanism, but anything you might need to flip at 2 a.m. evaluates at runtime, server-side, against cached rules. A second consequence: build-time client flags are visible in the browser bundle, so they are never a security boundary — they hide UI, not endpoints, and permission enforcement always lives server-side regardless of how the flag evaluates.

Q: When should I delete a feature flag?

A release toggle should be deleted within a sprint of reaching 100% rollout — the flag has done its entire job the moment the feature is fully released and stable, and every day it lingers is pure debt: an untested off-branch, a fork in every reader's mental model, and a doubling of the state space for zero remaining benefit. The deletion is not just removing the flag key; it is removing the dead branch the flag guarded, so the control-path code actually leaves the codebase rather than lurking behind an always-true condition. Experiment flags are deleted when the experiment concludes and the winning variant is promoted to permanent behavior. The flags that legitimately persist are the long-lived types by design: kill switches (they exist precisely to be available indefinitely for the rare bad day), permission toggles (they encode ongoing entitlement logic), and some ops toggles — but even these deserve periodic review to confirm they still guard something real. The enforcement that makes deletion actually happen, rather than being perpetually deferred: assign every flag an expiry date and an owner at creation, so a flag without a removal plan cannot be created; run a monthly stale-flag audit that surfaces any release toggle serving 100% or 0% for 30 days as a deletion candidate; and make the removal ticket part of the rollout definition of done, closing in the same sprint as the 100% milestone. Flag-management platforms report "flags at terminal state" specifically to drive this. The discipline is boring and the payoff is large: keeping the live-flag count low is the only thing that keeps the combinatorial state space within reach of a test suite.

Q: Can feature flags replace a staging environment or proper testing?

No — they change where and how you test, but they do not remove the need to test, and treating "we will just flag it and watch production" as a testing strategy is how flags become a liability. What flags legitimately enable is testing in production alongside, not instead of, pre-production testing: dark launches let you exercise new code paths against real data and real traffic shapes that staging can never fully reproduce, canary cohorts let you measure real user impact before full exposure, and internal-user targeting lets your own team dogfood a feature safely. Those are powerful and genuinely catch issues staging misses. But they rest on tests that must still exist. The off-state of every release flag needs a test, because that off-state is your rollback plan — an untested rollback is not a rollback, it is a second experiment you run while the first one is on fire. Both sides of every kill switch need testing, because you flip them during incidents when you least want a surprise. Flag interactions need at least pairwise testing where flags touch the same subsystem, because the combinatorial state space is exactly what unit tests of individual features miss. And the code behind a flag needs the same unit and integration coverage any code needs — flagging it off in production does not make it correct when flipped on. The honest framing: flags give you a safety mechanism (graduated exposure and instant rollback) that makes shipping less risky, and a testing surface (production, safely) that pre-production cannot match — but a safety mechanism you have not tested and a production experiment you are not measuring are both just risk with extra steps.