Alfa- vs bètatesten: verschillen en wanneer je welke draait
7 min lezen
Alfatesten is de eerste testronde, binnen het bedrijf uitgevoerd op een build waar nog onderdelen aan ontbreken en waarvan bekend is dat hij instabiel is. Bètatesten volgt daarna: een build die feature-compleet is, of bijna, gaat naar echte gebruikers buiten het team, die hem in hun eigen omgeving gebruiken en melden wat stukgaat of verwarrend is. Alfa beantwoordt de vraag of de software überhaupt werkt. Bèta beantwoordt de vraag of hij werkt voor de mensen voor wie hij is gebouwd, op hun machines, met hun data en hun gewoonten.
| Alfatesten | Bètatesten | |
|---|---|---|
| Wie test | Ontwikkelaars, QA, ander personeel | Klanten en vrijwilligers buiten het bedrijf |
| Staat van de build | Er worden nog features toegevoegd, veel bekende bugs | Feature-compleet of bijna, bugs verwacht |
| Omgeving | Lab, staging of de eigen accounts van het team | Echte apparaten, echte data, echte workflows |
| Hoofdvraag | Werkt het zoals ontworpen? | Werkt het voor echte gebruikers? |
| Typische feedback | Precieze bugmeldingen met stappen | Symptomen, verwarring, ontbrekende features |
| Wat het beëindigt | De build is compleet en stabiel genoeg om aan buitenstaanders te laten zien | Geen blokkades meer en de feedback neemt af |
Wat is alfatesten?
Alfatesten is intern testen van een vroege build. De mensen die testen kennen het product, kunnen logs lezen en weten dat dingen zullen breken, dus het doel is de grote problemen te vinden voordat iemand buiten het team ze ziet.
Het Wikipedia-artikel over de software release life cycle beschrijft de alfafase als de eerste fase van het testen van software: ontwikkelaars testen met white-boxtechnieken, en een apart testteam valideert de build daarna met black-box- of gray-boxtechnieken. Veel teams voegen er een derde laag aan toe, namelijk medewerkers die het product voor hun eigen werk gebruiken. Die praktijk heeft een eigen naam, dogfooding, en ze vindt de wrijving die een script nooit raakt.
Wat is bètatesten?
Bètatesten zet een bijna afgeronde build voor echte gebruikers voordat de algemene release uitkomt. Het vangt de problemen die pas buiten het gebouw zichtbaar worden: andere apparaten en browsers, rommelige data, ongewone workflows en mensen die de binnenkant van het product nooit hebben gezien.
Hetzelfde Wikipedia-artikel zegt dat een bètafase doorgaans begint wanneer de software feature-compleet is, maar waarschijnlijk bekende of onbekende bugs bevat. Een gesloten bèta nodigt een gekozen groep uit, vaak klanten die om de feature vroegen of designpartners. Een open bèta laat iedereen meedoen. Sommige producten blijven in wat een eeuwige bèta heet: continu bijgewerkt en nooit als af bestempeld.
Wat is het verschil tussen alfa- en bètatesten?
Tussen de twee fasen veranderen vier dingen: wie test, hoe af de build is, waar hij draait en wat er met een melding gebeurt. Alfatesters zijn insiders die op een onvolledige build werken in een gecontroleerde opzet, terwijl bètatesters buitenstaanders zijn die een complete build voor echt werk gebruiken.
Het laatste verschil is het belangrijkst voor de mensen die de meldingen lezen. Een alfamelding komt meestal van iemand die de code kent, het onderdeel noemt en de stappen meegeeft. Een bètamelding komt van iemand die een symptoom zag, en dezelfde oorzaak kan als vijf verschillende klachten binnenkomen. Bètafeedback heeft dus triage nodig voordat ze bij ontwikkelaars komt: bugs scheiden van verzoeken, duplicaten samenvoegen en vervolgvragen stellen zolang de tester nog weet wat hij deed.
Moet je een gesloten of een open bèta draaien?
Begin gesloten en open de bèta pas als je schaal of variatie nodig hebt die je niet met de hand kunt werven. Een gesloten groep is makkelijker te ondersteunen en laat minder snel een onaffe feature uitlekken.
De appstores hebben deze volgorde in hun tooling ingebouwd. Google Play kent drie testtracks: interne tests voor maximaal 100 testers, gesloten tests voor een bredere uitgenodigde groep en open tests waaraan iedereen kan meedoen. Nieuwe persoonlijke ontwikkelaarsaccounts die na 13 november 2023 zijn aangemaakt moeten een gesloten test draaien met minstens 12 testers die minstens 14 dagen aaneengesloten zijn aangemeld, voordat ze productietoegang kunnen aanvragen. Met Apples TestFlight kun je maximaal 100 interne testers uit het ontwikkelteam en maximaal 10.000 externe testers uitnodigen, en de eerste build voor externe testers moet door App Review worden goedgekeurd. Alle drie de cijfers zijn gecontroleerd op 16 oktober 2026.
Hoe versioneer je alfa- en bètabuilds?
Geef elke build een versie die zegt bij welke fase hij hoort en die in releasevolgorde sorteert. Pre-releasesuffixen doen allebei.
Semantic Versioning markeert een pre-release met een koppelteken en door punten gescheiden identifiers na de versie waar je naartoe werkt. Het eigen rangorde-voorbeeld van de specificatie loopt zo: 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta < 1.0.0-beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0, dus de fasen sorteren goed zonder speciale afhandeling. Tag elke build in git zoals beschreven in git tags en releases, en als de bèta eindigt, is de volgende fase een release candidate.
Hoe verzamel en triëer je bètafeedback?
Geef testers één duidelijke plek om te melden, het liefst in het product zelf, en vraag wat ze deden, wat ze verwachtten en wat er gebeurde. Sorteer daarna elke melding in bug, featureverzoek of vraag, voeg duplicaten samen en antwoord de tester.
E-mailthreads en chatkanalen voelen aan het begin van een bèta gezellig en zijn binnen een week niet meer te doorzoeken. Een formulier of widget in het product legt de pagina, de versie en het account vast zonder dat de tester die hoeft te typen. Het onderscheid tussen een featureverzoek en een bugreport is de moeite waard bij de intake, omdat de twee naar verschillende eigenaren gaan, en dubbele featureverzoeken moet je samenvoegen met behoud van hun aantallen, want tien testers die om hetzelfde vragen is op zichzelf al een bevinding. In Changeloop wordt een melding via de feedbackwidget een GitHub-issue met het label bug of feature-request, plus een prioriteitslabel en from-widget, zodat bètafeedback in dezelfde tracker belandt als het werk waar ze over gaat.
Wanneer is een bètatest klaar?
Een bèta is klaar als de resterende problemen bekend zijn, geen ervan de release blokkeert en nieuwe meldingen tot een druppel zijn afgenomen. Schrijf de exitcriteria op voordat de bèta begint, anders eindigt hij vaak op de datum die iemand aan een klant beloofde.
Een werkbare set exitcriteria:
- Geen open bug is als blokkade beoordeeld.
- Crash- en foutpercentages liggen op of onder het niveau dat je voor de release hebt vastgesteld.
- Het aantal nieuwe meldingen per dag is gedaald en de meeste herhalen bekende problemen.
- De meest gevraagde wijzigingen zijn gedaan of uitdrukkelijk uitgesteld, en testers weten welke.
- Supportdocumentatie en release notes zijn opgesteld op basis van waar testers echt moeite mee hadden.
Als dit allemaal klopt, bevries je de features en maak je de eerste release candidate. Bugs die je daarna vindt, los je alleen op als ze het uitbrengen blokkeren.
Hoe sluit je de loop met bètatesters?
Vertel testers wat er met hun melding is gebeurd, in hetzelfde kanaal waarin ze die deden. Mensen die zien dat hun feedback in fixes verandert, blijven testen, en mensen die niets horen, stoppen.
Stuur bij elke nieuwe bètabuild een korte notitie met de fixes die uit testermeldingen kwamen, en zeg duidelijk welke verzoeken de release niet halen. Als de definitieve versie uitkomt, horen de release notes de wijzigingen te vermelden die testers hebben aangedreven; de release notes template geeft daar een structuur voor. Changeloop doet dit per melding: wanneer een changelog-entry die aan een widgetissue is gekoppeld wordt goedgekeurd, krijgt het issue één reactie dat de wijziging is uitgebracht, met een link naar de entry op de publieke changelog. De bredere praktijk staat in de feedback-loop sluiten vanuit de changelog.
FAQ
Is bètatesten hetzelfde als acceptatietesten door gebruikers? Ze overlappen en beantwoorden verschillende vragen. Acceptatietesten door gebruikers toetst de software aan afgesproken eisen, meestal door de klant of de business owner vóór de oplevering, terwijl bètatesten bekijkt hoe een bredere groep het product in de praktijk gebruikt.
Kan een klein team alfatesten overslaan? Het kan het inkorten, en helemaal overslaan is riskant. Zelfs een paar dagen waarin het team de build voor echt werk gebruikt, voordat iemand buiten het team hem ziet, haalt de crashes en kapotte flows weg die anders de eerste indruk van testers verpesten.
Wat komt er na bètatesten? Een release candidate, daarna general availability. De kandidaat is een build met bevroren features die ongewijzigd wordt uitgebracht tenzij testen een blokkade vindt, en de definitieve release is diezelfde build met een ander label.
Hoeveel bètatesters heb je nodig? Genoeg om de platforms, accounttypen en hoofdworkflows te dekken die het product ondersteunt. Sommige stores stellen ook een ondergrens, zoals de gesloten test met 12 testers en 14 dagen die Google Play van nieuwe persoonlijke ontwikkelaarsaccounts eist.
De technische beweringen in dit artikel zijn niet onafhankelijk gecontroleerd. Klopt er iets niet, laat het ons weten, dan corrigeren we het.