Feature flags maken het mogelijk om code te deployen zonder nieuwe functionaliteit direct voor iedereen beschikbaar te maken. Lees hoe verschillende soorten flags werken, hoe je ze beheert en welke technische risico’s ontstaan als tijdelijke flags permanent blijven.
Feature flags scheiden deployment van release
Je ziet een feature flag meestal als een simpele voorwaarde in de code. Die bepaalt of iets in de applicatie aanstaat of niet. De functionaliteit zelf zit dan al in productie, maar blijft onzichtbaar voor gebruikers. Daarmee krijg je twee aparte keuzes: wannéér je code deployed en wannéér een functie daadwerkelijk voor eindgebruikers aan gaat. Dat is vaak handig als teams tegelijk werken aan verschillende onderdelen, als nieuwe functies afhankelijk zijn van systemen buiten je controle, of als je iets eerst op kleine schaal wilt aanklikken voordat iedereen het merkt.
Je kunt een flag instellen in een externe beheeromgeving, als omgevingsvariabele of gewoon als instelling binnen de applicatie. Wat je kiest, bepaalt hoeveel gedoe het is om een flag te veranderen, en hoeveel je applicatie afhankelijk is van centrale configuratie. Een flag via een beheerplatform kun je meestal live aanpassen zonder nieuwe deployment, maar haalt wel een extra systeem binnen. Gebruik je lokale config, dan heb je bij netwerkproblemen minder kans op ellende, maar moet je meestal wel opnieuw deployen om de waarde aan te passen.
Met een feature flag omzeil je het releaseproces niet. Onzichtbare code kan alsnog iets stuk maken, misschien direct bij het opstarten of juist als je bestaande logica raakt. Test dus óók als iets uit staat en kijk meteen of het werkt als instelling niet beschikbaar is. Let vooral op bij het ontwerp: wat gebeurt er als de flag er niet is of de configuratieserver niet bereikbaar? Daar kun je zomaar het meest last van krijgen. Voor maatwerk met feature flags in PHP is PHP-ontwikkeling een passende basis.
Release flags voor gefaseerde ingebruikname
Een release flag gebruik je om iets nieuws te verstoppen tot het echt af is. Je brengt de code alvast in productie en zet de functie eerst alleen aan voor jezelf of voor een klein clubje gebruikers. Daarna kun je, als dat goed gaat, het aantal langzaam opvoeren tot iedereen het ziet. Zo hoeft er geen nieuwe release uit om de zichtbaarheid te switchen. Vergeet niet: code die in productie staat, kan toch aangeroepen worden als de flag verkeerd staat, dus blijven testen is gewoon nodig.
Je moet precies afbakenen wie toegang krijgt. Dat kun je regelen per account, gebruiker, locatie of simpelweg via een percentage van de gebruikers. Bij procentuele uitrol heb je meestal een vaste sleutel zoals een gebruikers-ID nodig, want bij een willekeurige toewijzing kun je per verzoek een andere uitkomst zien. Daardoor krijg je inconsistent gedrag, iets dat moeilijk na te bootsen is en onhandige effecten geeft als een workflow half-af blijft hangen.
Maak van tevoren duidelijk op welke signalen je let om verder te rollen. Kijk bijvoorbeeld naar foutmeldingen, laadtijden, gebruikscijfers of wat de monitoring laat zien. Plots iedereen tegelijk activeren geeft weinig controle, zeker als er extra last op je database of een externe API bij komt. Denk ook aan de koppeling van onderdelen: stel je hebt een feature in de frontend en een andere flag voor een benodigde backendroute, dan wil je voorkomen dat één van de twee wordt vergeten en een gebruiker ineens op een technische doodlopende weg uitkomt.
Experimentflags voor gecontroleerde producttests
Met een experimentflag kun je groepen gebruikers verschillende versies laten zien. Daarmee test je of een wijziging het gewenste effect heeft. Het draait dus niet om beschikbaarheid, maar om wie in welke testgroep valt en hoe je meet wat er gebeurt. Een goed experiment heeft altijd vooraf een duidelijke hypothese, een geschikte meetmethode en een systeem dat garandeert dat gebruikers steeds dezelfde variant te zien krijgen tijdens de looptijd.
Je kunt niet simpelweg bij elke page load random kiezen, dan kan iemand tijdens een sessie wisselen van variant terwijl je gedrag over tijd probeert te meten. Koppelen aan een gebruiker of account levert vaker consistente groepen op, maar dan zit je wel met privacy, opslag en de vraag wat je doet bij gasten die niet ingelogd zijn. In B2B-software kun je beter op organisatieniveau verdelen als alle collega's dezelfde versie moeten gebruiken.
Slechte implementatie beïnvloedt je resultaat. Stel je testpagina is trager, valt vaker uit of draait niet op elke telefoon: dan meet je misschien onbedoeld technische ruis in plaats van het effect van de wijziging zelf. Denk goed na over hoe je omgaat met ontbrekende data, bots, interne gebruikers en gebruikers die voor het einde afhaken. De indeling en variantinformatie moet terugvindbaar zijn. Na afloop hoort een experimentflag weg, of integreer je de gekozen variant in de reguliere code.
Operationele flags en kill switches
Een operationele flag regelt hoe de applicatie omgaat met beschikbaarheid, belasting of externe afhankelijkheden. Een kill switch kun je bijvoorbeeld inzetten om een koppeling naar een traag platform of een kostbare achtergrondtaak acuut uit te schakelen als het misgaat. Anders dan bij een gewone release is het doel hier vooral operationeel, je wilt de boel snel bijsturen als een onderdeel lastig doet. Of dat werkt, hangt er wel van af of je de flag nog wél kunt bedienen als er iets stuk is.
Als een centrale configdienst onderuit ligt, moet de applicatie zelf weten wat er moet gebeuren. Soms is uitschakelen veiliger, denk aan een optionele taak. Andere keren wil je juist niet dat een flag automatisch uit staat, zeker niet bij iets als authenticatie. Maak dat onderscheid expliciet, test het, en zorg dat het gedrag zichtbaar is in monitoring. Een schakelaar die alleen werkt als alles verder gezond is, helpt niet echt als een probleemsituatie begint bij bijvoorbeeld een database of configserver.
Hou rekening met wat je niet direct ziet. Zet je een integratie uit, kunnen er bijvoorbeeld wachtrijen ontstaan die bij het weer aanzetten plots een grote golf requests opleveren. Soms wil je daarom batches verwerken of limieten stellen. Beperk wie deze flags mag bedienen, en zorg altijd voor een auditlog met tijd, wie het deed en waarom. Wie aan de knoppen zit zonder sporen na te laten, maakt foutzoeken en incidenten lastiger, zeker in stressvolle situaties.
Permissies en feature flags zijn verschillende mechanismen
Je kunt met een feature flag bepalen welke accounts toegang krijgen tot bepaalde functies, maar de flag zelf is geen autorisatiemiddel. Een verborgen knop zorgt er niet voor dat een slimme gebruiker niet via de API probeert op plekken te komen die niet zijn bedoeld voor hem of haar. De backend hoort altijd zelf te checken of iemand ergens bij mag, gebaseerd op rol, identiteit en beleid, niet alleen op zichtbaarheid van een knopje in de frontend.
Maak altijd onderscheid tussen tijdelijke beschikbaarheid en structurele rechten. Een flag regelt of iets technisch aan staat tijdens de uitrol. Een entitlement bepaalt welke features een account mag gebruiken volgens contract of configuratie. Je kunt ze allemaal als config bewaren, maar ze zijn niet hetzelfde qua eigenaar, duur of foutafhandeling. Gooi je alles op één hoop, dan raak je het spoor bijster als iemand geen toegang blijkt te hebben, was het een beleid, een tech-issue, of een release die ooit is blijven hangen?
Documenteer waar en hoe de toegang wordt gecontroleerd en afgedwongen. Vaak valideert de backend permissies, terwijl de frontend vooral voor gebruiksgemak menu’s aanpast. De frontend schept comfort, niet veiligheid. Let ook op hoe wijzigingen doorwerken in caches of achtergrondprocessen: rechten die zijn ingetrokken mogen niet via oude data actief blijven. Door flags, permissies en productrechten strak te scheiden houd je grip op audits en incidentonderzoeken.
Configuratie, evaluatie en consistent gedrag
Het is belangrijk om feature flags steeds op dezelfde manier en plek te evalueren. Als frontend, API en achtergrondprocessen elk op hun eigen manier uit dezelfde config lezen, krijg je uiteenlopend gedrag. Een centrale laag voor evaluatie maakt het makkelijker overzicht te houden, denk aan standaardwaarden, doelgroepen en logging. Maar dat hoeft niet te betekenen dat álles via één externe dienst moet. Je kunt configuratie ook lokaal opslaan, cachen en vooraf bepalen wat er gebeurt als iets ontbreekt of verouderd raakt.
Zorg dat uit de config direct duidelijk is voor welk account, omgevingsniveau of gebruiker een regel geldt. Een accountinstelling mag niet plots overschreven worden door per-omgeving config. Bepaal welke regels voorrang hebben, en test uitzonderingen, lege velden of onbekende accounts extra goed. Gebruik een vaste hash-methode voor varianten zodat dezelfde gebruiker of account consequent dezelfde beslissing krijgt, ook over verschillende processen heen.
Zie configuratie als een volwaardig onderdeel van je software en zet het onder versiebeheer of log het centraal. Waar, wie, wanneer en wát is veranderd, dat wil je terugvinden. Zorg dat geheime data niet onbewust in flags komt te staan; dat kan breder uitleesbaar zijn dan je denkt. Let ook op de snelheid waarmee config wordt ververst na een update. Snelle refresh kan handig zijn voor correcties, maar zorgt bij een storing wel voor extra druk. Langzaam cachen helpt bij stabiliteit, maar vertraagt wijzigingen, dus maak een bewuste afweging.
Eigenaarschap, documentatie en teststrategie
Zonder duidelijke eigenaar blijft het doel van een feature flag vaak alleen in het hoofd van het ontwikkelteam hangen. Plaats daarom altijd metadata bij een flag: wat doet het, wie is verantwoordelijk, waarom bestaat die flag en wanneer kan die eruit? Alleen het label 'voor tijdelijke test' is niet genoeg als niemand weet wat het bedoelde testresultaat was of wanneer de test als afgerond geldt.
Test altijd het gedrag met de flag aan én uit. Vergeet ook de minder voor de hand liggende situaties niet, bijvoorbeeld als de flag überhaupt ontbreekt in de config, of als de provider een error terugstuurt. Heb je meerdere flags tegelijk, dan lopen de aantallen combinaties snel op. Je hoeft niet elke variant als complete eind-tot-eindtest te draaien, maar modelleer kritisch belangrijke samenhangende situaties. Meerdere afzonderlijk juiste flags kunnen samen alsnog een fout opleveren.
Monitoring hoort te laten zien welke variant een verzoek gebruikt, maar log niet onnodig persoonsgegevens. Je wilt kunnen achterhalen waarom prestaties of fouten verschillen tussen varianten. Dashboards en alerts horen het verschil te laten zien tussen een functie die bedoeld is uitgeschakeld en eentje die defect is. Vooral bij incidenten heb je zicht nodig op of de flagwaarde zelf is aangepast of juist de functionaliteit erachter stuk is gegaan. Dus eigenaarschap betekent niet alleen code schrijven, maar ook: volgen, documenteren en uiteindelijk opruimen. Voor logging en foutafhandeling in automatiseringen, zie betrouwbare automatisering. Een freelance developer kan die implementatie en het beheer samen oppakken.
Verouderde feature flags verwijderen zonder regressies
Feature flags die niet meer nodig zijn, stapelen technische schuld op. Ze maken code onduidelijk, vergroten de testlast en houden soms onbedoeld uitzonderingen in stand. Een vergeten flag betekent vaak dat er onnodig twee codepaden in leven blijven, terwijl er in werkelijkheid nog maar één gebruikt hoort te worden. Oude targetingregel? Dan kan per ongeluk nog een deel van je gebruikers op een afwijkende variant terechtkomen, zonder dat iemand het doorheeft.
Begin met uitzoeken of een flag überhaupt nog actief ergens een rol speelt. Zoek in code, config, infrastructuur en rapportages. Kijk welke waarde feitelijk per omgeving actief is, en of er ergens uitzonderingen zijn voor bijvoorbeeld losse accounts. Zet eerst de standaardvariant aan of haal een niet meer gebruikte weg, ruim daarna stap voor stap de flag en ondersteunende configuratie op. Als meerdere diensten aan dezelfde flag hangen, moeten die wijzigingen in een volgorde die samen werkt en rekening houdt met tussenliggende versies.
Bij flags die niet tijdelijk zijn maar structureel operationeel bedoeld, behandel je ze anders: beschrijf doel, wie de eigenaar is, welk gedrag je verwacht bij fouten en hoe je periodiek controle houdt. Probeer met tooling te signaleren welke flags hun houdbaarheidsdatum naderen of waar er geen verwijzingen in de code meer zijn. Ongezien verwijderen zonder te checken leidt tot verrassingen, maar alles laten staan houdt oude beslissingen onnodig in leven. Duidelijke classificatie en een gecontroleerde overgang zijn onmisbaar voor gezond beheer van flags.
Veelgestelde vragen
Wat is het verschil tussen feature flags en feature branches?
Een feature branch is bedoeld voor gescheiden ontwikkelwerk; een feature flag bepaalt welk gedrag gebruikers zien nadat de code al is samengevoegd en uitgerold. Met een branch werk je lokaal aan een nieuw stukje, los van de rest van het team. Een flag, daarentegen, laat je verschillende codepaden tegelijk uitvoeren, afhankelijk van de configuratie of doelgroep. Het gebruik van een flag voorkomt dus niet dat code wordt samengevoegd of getest, maar wel dat je vastzit aan één uitvoering voor alle gebruikers.
- Gebruik branches om tijdelijk apart te werken aan nieuwe functies of wijzigingen.
- Gebruik flags als je wilt kiezen wanneer een eenmaal uitgerolde functie daadwerkelijk aan of uit staat voor gebruikers of groepen.
Hoe verwijder je een feature flag veilig nadat een functie is uitgerold?
Je verwijdert een feature flag veilig door te zorgen dat duidelijk is welk codepad overblijft, die variant actief te maken en vervolgens de flag met bijbehorende alternatieve stukken code en configuratie op te ruimen. Check vooraf of er nog accounts, omgevingen of processen zijn die stiekem nog de oude instelling gebruiken, dat wil je anders oplossen voordat je de flag eruit gooit.
- Zet de gekozen variant aan als standaard en controleer of die werkt zoals bedoeld.
- Verwijder de flag zelf en de codepaden die daar alleen voor bestonden.
- Ruim targeting, config en eventuele tests op die louter bij de flag horen.
- Test alles wat relevant is en kijk via monitoring of het gedrag klopt na deployment.
Hoeveel feature flags zijn te veel voor een applicatie?
Er is geen harde grens aan hoeveel feature flags te veel zijn. Het wordt pas een probleem als teams het overzicht kwijtraken over welke flags er actief zijn, wie de eigenaar is, waar ze voor dienen of wanneer ze weggemogen hadden. Elke flag maakt potentiële codepaden en confugnaties bij, dus het werkelijke knelpunt is hoeveel verschillende situaties je nog kunt testen en begrijpen voordat het fout gaat.
- Loop regelmatig je flags na: heb je nog flags die nooit veranderen of die geen doel meer hebben?
- Geef tijdelijke flags een echte eigenaar en een volgend moment waarop je opnieuw beslist of die nog nodig is.
- Let extra op als flags elkaar kunnen beïnvloeden of combineren.
- Gooi flags die klaar zijn weg, niet blijven laten staan op uit.
Kun je feature flags gebruiken in een mobiele app?
Ja, je kunt feature flags toepassen in een mobiele app, maar houd wel rekening met gebruikers die de app niet direct updaten en met het feit dat configuratie niet altijd bereikbaar zal zijn. Op de server kun je een feature uitschakelen, maar als de code al op het toestel staat blijft die bestaan tot een nieuwe versie wordt geïnstalleerd. Dus moet je app ook zonder recente of volledige config veilig en bruikbaar blijven werken, ook zonder netwerkcontact.
- Bepaal welke instellingen lokaal mogen blijven staan en hoe lang die geldig zijn.
- Test wat er gebeurt als de configuratie leeg, verouderd of niet bereikbaar is.
- Gebruik flags niet als alternatief voor autorisatie op de server.
- Check of oudere appversies overweg kunnen met nieuwere configvelden.
Maken feature flags een applicatie trager?
Feature flags kunnen voor vertraging zorgen als je voor elke beslissing een netwerkcall moet doen of als de evaluatie ingewikkeld is. Bij lokaal geladen en gecachte config is de impact normaal gesproken beperkt, maar het hangt af van hoe je het hebt ingericht en hoe vaak een flag wordt bekeken. Meet wat een flagcontructie doet met laadtijd en foutkans, zeker op routes die vaak gebruikt worden.
- Laad waar je kunt je configuratie vooraf of werk met een cache.
- Vermijd losse netwerkaanvragen voor elke check op een flag.
- Meet hoe lang een flagbeslissing duurt en wat er gebeurt bij een miss in de cache.
- Denk na over balans tussen snelle wijzigingen kunnen doen en afhankelijk zijn van externe systemen.
Foto: Castorly Stock