Skip to content
Novandri.

Feature Flags Checklist

Feature flags separate deployment from release. Read a checklist linking toggles, canary rollout, and CI gates, with a worked example and a decision test.

Rachmadwipa Novandri7 min read

Feature flags are often adopted as a convenient way to hide unfinished work. The real problem is that a flag creates a new branch of behavior that must be tracked, tested, and eventually removed, and teams frequently ship the flag without that plan. The code is safe to deploy, but the release is harder to reason about than before.

Direct answer: A feature toggle lets a team switch a feature on or off at runtime, and the canary release technique exposes a change to a limited subset of users first; GitHub Actions provides a way to automate the build, test, and deployment steps around them. The boundary is that a flag is a control surface, not a test of whether the feature is wanted or correct.

Delta: This article adds a release decision beyond the sources: it maps the toggle mechanism, canary rollout, and CI automation to a checklist that keeps each flag reversible and removable, with claim status explicit.

The mechanism

The feature toggle entry describes a technique for enabling or disabling functionality without changing and redeploying code. The core mechanism is a runtime switch that separates deployment, getting code onto a system, from release, deciding who sees a behavior. The practical consequence is that code can ship dark and activate later, and that a problematic release can often be stopped by flipping a switch. Each flag, however, introduces a branch that the code must support for as long as the flag exists.

A feature flag rollout moving from internal to canary to full release, with a kill switch to revert.
Conceptual: each stage is reversible; the flag separates deploy from release.

The canary release concept, covered at the same source, is to expose a change to a small subset of users before widening it. The mechanism is progressive exposure: a limited cohort absorbs the first failures while the rest of the traffic stays on the known state. The practical consequence is that flags and canary rollout fit together naturally. A flag supplies the switch, and a targeting rule supplies the cohort, so monitoring the small group can reveal problems before full rollout.

GitHub Actions documentation describes workflows that automate build, test, and deployment tasks. The mechanism relevant here is repeatable automation: checks run the same way on every change, defined in configuration held with the code. The practical consequence is that the checklist becomes executable rather than a matter of memory. A workflow can verify that a flag has a default state, that the off path is exercised, and that the change passed tests before it reaches a canary cohort.

Taken together, the sources point to a lifecycle rather than a single switch.

A useful flag has an owner, a defined rollout, a tested off state, and a removal date.

The decision of whether to add one rests on whether the team can carry that lifecycle. Where it cannot, a flag becomes permanent scaffolding that quietly raises the cost of every later change.

A worked example

The following is hypothetical and illustrative. A team is shipping a redesigned checkout behind a flag and wants the change to be reversible. Three checks structure the release. First, the ownership check: does the flag have a named owner and a planned removal date, so it does not outlive the experiment? Second, the control check: is the off state exercised in the automated workflow, and can the flag be flipped without a new deployment? Third, the rollout check: does the change reach a small canary cohort first, with monitoring in place before wider exposure? The outcome is that the checkout ships to the cohort, a defect appears in that small group, and the flag is switched off without a full outage. The limitation is that the flag remains as technical debt if nobody carries out the removal step.

Evidence status

ClaimStatusSourceVerifiedRecheck when
Feature toggles switch functionality without a new deploymentsource-reportedFeature toggle - Wikipedia2026-11-18the technique's definition changes
Canary releases expose a change to a limited subset before wider rolloutsource-reportedFeature toggle - Wikipedia2026-11-18rollout practices in the entry change
CI workflows automate build, test, and deployment taskssource-reportedGitHub Actions Documentation2026-11-18the platform's workflow model changes
Linking flag ownership and exit criteria to CI gates reduces orphaned flagsinferredDerived from the sources2026-11-18team release process changes

The first three rows report what the sources state directly and can be checked against them. The fourth is an inference: it combines a runtime switch, a staged rollout, and automated checks, but no source presents it as a rule. Recheck conditions point to the underlying sources or to local process changes, so each row's status stays visible rather than assumed.

What it cannot do

A feature flag cannot tell a team whether a feature is good. It controls exposure, not value. A perfectly toggled feature can ship to every user and still solve a problem nobody has. The sources describe a switch and a rollout pattern; neither validates the idea behind the change. Treating a clean rollout as evidence of product success confuses the mechanics of release with the question of whether the release should exist.

The hidden cost is combinatorial complexity. Each flag multiplies the states the system can be in, and the number of meaningful combinations grows with every new switch. Code paths guarded by old flags are rarely exercised, so they rot quietly. Testing burden rises not because any one flag is hard, but because the interactions between them are hard to enumerate. Teams that add flags freely often discover the cost only when a late change breaks an old branch nobody remembered.

A flag intended as a kill switch is useful only if flipping it produces a healthy state, yet that path is exactly what accumulates neglect. A kill switch that itself needs a deployment defeats its purpose, and a default that was correct at launch can be wrong after later edits. Likewise, a flag whose targeting rule is too broad can expose a change far beyond the intended cohort, turning a canary into a full release by accident.

The boundary of the sources is worth stating. They provide a development technique and a CI platform, not a hygiene policy. The decision to remove a flag after rollout, the ownership model, and the rule for when a flag is justified are local choices. Claiming that the sources mandate a particular flag lifecycle overstates what they support; they make such a lifecycle possible, not compulsory.

Because code and teams change, the flag set needs scheduled review. An experiment ends, a team reorganizes, and the owner of a flag leaves; the switch itself does not notice. A practical cadence is a periodic audit that lists active flags, their owners, their intended removal dates, and the last time each off path was tested. Anything past its date is either removed deliberately or given a fresh justification. Without that review, the flag set becomes a record of decisions nobody is making anymore.

The counterargument that feature flags add code complexity is fair for a single small release and incomplete for systems that need frequent, reversible rollouts, where the ability to stop a change quickly outweighs the cost of the extra branch.

A decision test

  1. State the decision the flag is meant to make reversible.
  2. Name an owner and a removal date before adding the switch.
  3. Define the default state and the intended cohort.
  4. Exercise the off path in the automated workflow.
  5. Gate the release on passing build and test checks.
  6. Roll out to a small canary cohort before widening exposure.
  7. Audit active flags on a fixed cadence and remove expired ones.

These steps convert a runtime switch into a controlled release with visible exit criteria. The mapping from toggles, canary exposure, and CI automation to a checklist is what makes the decision reviewable. A passed test leaves a flag that can be stopped, traced to an owner, and removed on purpose.

For further reading, see AI Risk Assessment: A Pre-Deployment Checklist.

References & Further Reading