Feature flag
A feature flag is a configuration control that conditionally enables, disables, or selects software functionality at build time or runtime.
Platform Engineering on Kubernetes
A feature flag is a runtime-controlled configuration mechanism that enables or disables application functionality without changing or restarting the application.
- How it is used
- Separates deployment of new service code from decisions about when its features become available to customers.
- How deep it goes
- Works through multi-service flag variants and an SDK evaluation call, while leaving storage and provider management to the platform capability.
- Examples
- Uses FEATURE_DEBUG_ENABLED, a Conference eventsEnabled flag with three variants, and an OpenFeature ObjectValue call.
- What you can do after
- Apply it via OpenFeature to evaluate a shared flag and change a running Conference application's behavior without restarting components.
Read how Platform Engineering on Kubernetes explains feature flag →
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
A feature flag is a Boolean-controlled configuration mechanism that enables or disables a feature, resource, dependency, or attribute.
- How it is used
- Stages, tests, and hides infrastructure changes before applying them to production or exposing them to collaborators.
- How deep it goes
- Demonstrates definition, defaulting, conditional references, activation, and removal, but does not detail configuration-manager implementation.
- Examples
- Uses Python, JSON, Terraform, and CloudFormation examples to switch server modules and load-balancer membership.
- What you can do after
- Apply it via infrastructure as code to stage changes and limit their immediate impact on existing resources.
Django in Action
A feature flag is a conditional control that enables or disables application functionality according to configuration or runtime criteria.
- How it is used
- Limits production risk by exposing new functionality only to selected users.
- How deep it goes
- Explains conditional rollout, three Waffle control types, installation, configuration, migrations, and activation checks.
- Examples
- Uses Waffle switches for global rollout, samples for percentage rollout, and flags for role, account, language, or group targeting.
- What you can do after
- Apply feature rollouts via Django Waffle using switches, samples, and flags.
Grokking Software Architecture
A feature flag is a runtime switch that changes application behavior without requiring a new deployment.
- How it is used
- Separates deploying code from releasing functionality by controlling runtime behavior with a switch.
- How deep it goes
- Defines runtime switching and explains dark launches, targeted activation, and a data-write safety latch.
- Examples
- Uses an enterprise discount code path, QA-only activation, and an emergency switch for legacy data formats.
- What you can do after
- Operate a release switch to expose new logic selectively or disable a risky data-writing path.
Read how Grokking Software Architecture explains feature flag →
Learn Rust in a Month of Lunches
A feature flag is a configuration option that conditionally enables code, dependencies, or capabilities during compilation.
- How it is used
- Controls which optional crate code and capabilities compile, helping projects avoid compiling functionality they do not use.
- How deep it goes
- Explains defaults, Cargo.toml syntax, compiler visibility, and source-level cfg gating, but does not develop flag implementation beyond these examples.
- Examples
- Uses reqwest's blocking client, Cargo feature listings, cargo add, Cargo.toml entries, and compiler errors for unavailable APIs.
- What you can do after
- Operate/configure Cargo dependencies by inspecting feature lists and enabling required crate functionality explicitly.
Read how Learn Rust in a Month of Lunches explains feature flag →
The Coder Cafe
A feature flag is a configuration-controlled switch that dynamically enables or disables functionality.
- How it is used
- Reduces deployment risk by controlling functionality during changes and supporting safer experimentation and rollback.
- How deep it goes
- Defines dynamic enablement without redeploying code and connects it to blast-radius reduction, but does not detail flag evaluation or configuration design.
- Examples
- Uses safe experimentation, quicker rollback, and controlled deployment changes as practical applications.
- What you can do after
- Operate/configure functionality dynamically, experiment more safely, and roll back changes without deploying new code.
The AI Pocket Book
A configuration mechanism that controls which users see a given version of a feature.
- How it is used
- Uses controlled user exposure to make trunk-based deployment safer.
- How deep it goes
- Explains staged exposure and final switchover, but does not detail flag implementation or management.
- Examples
- Uses old-versus-new code paths, developers, and quality-assurance staff as the staged rollout example.
- What you can do after
- Operate/configure staged releases that validate new features before exposing them to every user.
Think Like a Software Engineering Manager
A feature flag is a runtime control that enables or disables a software feature without requiring a new release.
- How it is used
- Controls production features during phased releases, experiments, and incident response.
- How deep it goes
- Explains uses, benefits, A/B testing, and cleanup responsibilities but does not describe implementation mechanics.
- Examples
- Uses hidden buttons, percentage-based user assignment, customer-use analysis, and emergency feature deactivation.
- What you can do after
- Operate controlled production launches, experiments, and feature deactivation with lower release risk.
Read how Think Like a Software Engineering Manager explains feature flag →
GitHub Actions in Action: Continuous integration and delivery for DevOps
A feature toggle is a runtime-controlled switch that selectively enables or disables a software capability independently of deployment.
- How it is used
- Separates deployment from release so capabilities can be exposed, validated, or withdrawn independently.
- How deep it goes
- Explains switch-based old/new code selection, production validation, rollback, and gradual exposure without prescribing a flagging system.
- Examples
- Uses old-versus-new code switching and a monitored canary rollout through successive user rings.
- What you can do after
- Operate/configure it to stage production exposure and restore prior behavior by disabling a switch.
Code Like a Pro in Rust
A feature flag is a Cargo configuration option that enables or disables optional functionality, dependencies, or code.
- How it is used
- Configures optional crate capabilities, dependency features, conditional compilation, and stable-versus-nightly support.
- How deep it goes
- Explains Boolean feature definitions, dependency propagation, cfg integration, and trade-offs, but stops short of exhaustive Cargo semantics.
- Examples
- Uses serde, base64, SIMD, architecture backends, Cargo manifests, cfg-gated imports, and nightly compiler attributes.
- What you can do after
- Operate/configure Cargo features and conditional Rust code while evaluating compile-time, binary-size, compatibility, and maintenance trade-offs.
Also covered in
- Logs and Telemetry
- Google Anthos in Action
- Rust Web Development
- ASP.NET Core in Action, 3e
- Tiny CSS Projects
- Machine Learning System Design
- Build High Value Software SystemsIn early access (MEAP)
- "Looks Good to Me"
- Cloud Observability in Action
- Shipping Go: Develop, deliver, discuss, design, and go again
- Build AI-Enhanced Web Apps
What to know first
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
- crateA crate is a unit of Rust code compiled as a library or executable, comprising source code and its module hierarchy and distributable through package metadata.
- experimentationExperimentation is the planned investigation of a question or hypothesis by conducting trials or interventions and observing their outcomes.
- blue-green deploymentBlue-green deployment is a release pattern that maintains separate active and replacement environments and switches traffic between them after the replacement is validated.
Related concepts
- crateconfigures · A crate is a unit of Rust code compiled as a library or executable, comprising source code and its module hierarchy and distributable through package metadata.
- rollbackused by · Rollback is the reversal or discarding of changes to restore data, software, or system state to an earlier state.
- experimentationuses · Experimentation is the planned investigation of a question or hypothesis by conducting trials or interventions and observing their outcomes.
- Django Waffleimplemented by · Django Waffle is a Django package for controlling feature availability through switches, percentage-based samples, and user-targeted flags.
Questions about feature flag
What is feature flag?
A feature flag is a configuration control that conditionally enables, disables, or selects software functionality at build time or runtime.
Which Manning books explain feature flag?
Platform Engineering on Kubernetes, Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform, Django in Action, Grokking Software Architecture, Learn Rust in a Month of Lunches, The Coder Cafe, The AI Pocket Book, Think Like a Software Engineering Manager and 2 more.
What should I know before learning feature flag?
Manning books that teach feature flag usually introduce deployment pipeline, crate, experimentation and blue-green deployment first.
What is feature flag also called?
Feature flag is also called feature toggle.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.









