Feature Flags in Practice
A feature flag is an if statement deciding at runtime whether new code runs — making deployment separate from release. This video covers the mechanics — where flags are evaluated, how the decision reaches the running process — and the patterns that make flags safe: short-lived releases, kill switches, and gradual rollouts.
Topics covered:
- Deployment vs. release: why shipping code and enabling it are different events
- Flag evaluation: where the decision happens and how defaults keep code safe
- Flag distribution: config files, environment variables, and remote evaluation
- The kill switch: disabling a broken feature without a deploy
- Progressive rollout: percentage ramps and user buckets
- Canary correlation: linking a flag's rollout to metrics and error rates
- Flag hygiene: why permanent flags are debt and how to expire them
- The risks: flag interactions, stale branches, and the "it's in prod" trap
Related articles
Feature Flags and Release Engineering: Kill Switches, Rollouts, and Flag Debt
Feature flags decouple deployment from release — how flags work through their lifecycle, percentage rollouts and kill switches, and the debt flags create when nobody removes them.
The Law of Demeter in Practice
Message chains, the law of diminishing knowledge, and why 'don't talk to strangers' prevents the most brittle code you'll ever write.
Dependency Injection and Composition Roots: Why Containers Exist
Dependency injection moves construction out of classes and into a composition root — how constructor injection, lifetimes, and DI containers actually work, and why service locator is a trap.
More in Software Architecture
The Strangler Fig Pattern
How to replace a legacy system without a rewrite — routing by path, strangling features incrementally, and keeping both systems honest.
DetailsDomain-Driven Design Basics
The core of DDD without the ceremony — ubiquitous language, bounded contexts, aggregates, and where the model boundary actually goes.
DetailsService Mesh Explained
What a service mesh actually does — sidecars, mTLS, traffic routing, and observability — and the network plumbing it takes off your plate.
DetailsThe Saga Pattern Explained
How distributed transactions work without distributed locks — saga steps, compensating actions, and the orchestration vs. choreography split.
DetailsCQRS Explained
Command query responsibility segregation — separate read and write models, why they diverge, and what you actually gain from the split.
DetailsAPI Gateway Patterns
What an API gateway actually does — routing, auth, rate limiting, and aggregation — and which patterns matter for your traffic.
DetailsHexagonal Architecture, Visualized
Ports and adapters in one diagram — how hexagonal architecture keeps business logic independent of databases, HTTP, and everything external.
DetailsEvent-Driven Architecture Explained
How event-driven systems work — events, topics, and consumers — and what the broker actually guarantees in a distributed system.
DetailsMicroservices vs. Monolith
The honest engineering comparison — deployment boundaries, data ownership, failure domains, and the real costs of splitting a system.
DetailsDepth, delivered weekly
One technical dispatch a week — articles and episode notes before they go public.
One technical dispatch per week. No noise.