Wat zijn feature flags en hoe verhouden ze zich tot CI/CD?

Question

Accepted Answer

**Feature flags** (feature toggles) zijn voorwaarden die functies **tijdens runtime** in- of uitschakelen zonder code in te dienen. Ze **ontkoppelen deployment van release** — je kunt code continue inzetten terwijl je controleert wanneer en aan wie functies daadwerkelijk beschikbaar zijn, wat krachtige leveringspraktijken mogelijk maakt.

## Wat feature flags zijn

```text
A FEATURE FLAG wraps a feature in a runtime condition:
```

```js
if (featureFlags.isEnabled("new-checkout", user)) {
  return newCheckout();      // the new feature (if the flag is ON)
} else {
  return oldCheckout();      // the existing behavior (flag OFF)
}
// → toggle the flag at RUNTIME (config/dashboard) — no redeploy needed to change behavior
```

## Ontkoppeling van deployment en release

```text
KEY IDEA: DEPLOY code (with the feature OFF) ≠ RELEASE the feature (turn it ON):
  → merge & deploy incomplete/new features safely (hidden behind an off flag)
  → RELEASE by flipping the flag — independent of deployment, instant, no redeploy
  → "deploy continuously, release when ready" → supports trunk-based development & CI/CD
```

## Krachtige gebruiksscenario's

```text
✓ GRADUAL ROLLOUT — enable for 5% → 50% → 100% of users (like canary, at the app level)
✓ INSTANT KILL SWITCH — disable a broken feature INSTANTLY (no redeploy/rollback needed)
✓ A/B TESTING — show different variants to different users; measure
✓ TARGETED release — enable for specific users/segments (beta testers, regions)
✓ TRUNK-BASED dev — merge incomplete work safely (hidden behind flags)
```

## Overwegingen

```text
⚠️ Flags add COMPLEXITY (conditional code paths); accumulate TECHNICAL DEBT if not
   removed after a feature is fully rolled out → REMOVE stale flags
⚠️ Test both flag states; manage flags (a flag-management system for many flags)
```

## Waarom het belangrijk is

Inzicht in feature flags is waardevol kennisgebied op senior level omdat het een krachtige techniek is die **deployment van release ontkoppelt**, waardoor geavanceerde leveringspraktijken mogelijk worden die CI/CD aanvullen, dus relevant voor moderne, geavanceerde levering.

De kernwaarde — feature flags die functies in **runtime-voorwaarden** wikkelen zodat je ze kunt in-/uitschakelen zonder in te zetten — maakt de cruciale ontkoppeling van **deployment van release** mogelijk: je kunt **code continuous inzetten** (met functies verborgen achter uit-vlaggen, zelfs onvolledig werk) terwijl je **controleert wanneer en aan wie functies daadwerkelijk beschikbaar zijn** (door vlaggen om te schakelen) — scheiding van de technische handeling van inzetten van de bedrijfsbeslissing van vrijgeven.

Dit ondersteunt **"continuous inzetten, vrijgeven wanneer klaar"** en maakt trunk-based development mogelijk (onvolledig werk veilig samen voegen achter vlaggen).

Inzicht in de **krachtige gebruiksscenario's** toont hun waarde: **geleidelijke rollouts** (inschakelen voor toenemend percentage gebruikers, zoals canary op applicatieniveau), **directe kill switches** (beschadigde functie onmiddellijk uitschakelen zonder herstart of rollback — snel, waardevol beveiligingsmechanisme), **A/B testen** (varianten meten), en **gerichte vrijgaven** (specifieke gebruikers/segmenten, beta testing).

Deze maken vrijgaven veiliger en flexibeler dan alleen inzetten.

Inzicht in de **overwegingen** — dat vlaggen complexiteit toevoegen (voorwaardelijke codepaden) en **technische schuld ophopen** als niet verwijderd na volledige rollout (dus verouderde vlaggen moeten worden opgeruimd), en dat beide vlagtoestanden moeten worden getest — weerspiegelt volwassen, verantwoord gebruik.

Omdat feature flags geavanceerde, veilige leveringspraktijken inschakelen (ontkoppeling deploy van release, geleidelijke rollouts, directe kill switches, A/B testen, trunk-based development) die CI/CD aanzienlijk verbeteren, en omdat inzicht erin en hun afwegingen waardevol zijn voor moderne levering, is inzicht in feature flags waardevol kennisgebied op senior level — een krachtige techniek die CI/CD aanvult door deployment van release te scheiden, waardoor veiliger, flexibeler, beter gecontroleerde functielevering mogelijk wordt, wat geavanceerde leveringspraktijken weergeeft die door volwassen engineeringteams worden gebruikt.