Het is vrijdagmiddag en de release staat klaar. Een kleine aanpassing in de prijsberekening is doorgevoerd en de demo zag er prima uit. Maandagochtend blijkt dat de factuurexport niet meer klopt, omdat niemand die export opnieuw had bekeken. Het ging om één regel code, maar de klant belt wel. Zo'n situatie komt zelden door slordigheid. Meestal ontbreekt een afspraak over wat je test, wanneer en hoe diep.
Software testen doe je op meerdere niveaus: unit-, integratie-, systeem-, regressie-, performance- en acceptatietests. Elk niveau vangt een ander soort fout, dus je kiest op basis van risico: wat kost het als dit onderdeel stuk gaat, en hoe vaak verandert het? Snelle geautomatiseerde tests vormen de basis. Handmatig testen bewaar je voor wat menselijk oordeel vraagt.
Testen software: de soorten op een rij
Wie zoekt naar testen software, komt een stapel termen tegen. Dit zijn de soorten die je in de praktijk nodig hebt:
- Unittests: controleren één klein stukje logica, bijvoorbeeld een btw-berekening. Ze draaien in seconden en wijzen precies aan waar het misgaat.
- Integratietests: controleren of onderdelen samenwerken, zoals je applicatie met de database of met een externe API.
- Systeemtests: testen de complete applicatie als geheel, van inloggen tot het afronden van een bestelling.
- Regressietests: controleren dat wat gisteren werkte vandaag nog werkt. Ze zijn de reden dat een kleine wijziging niet ongemerkt de factuurexport sloopt.
- Performancetests: meten hoe het systeem zich gedraagt bij veel gebruikers of grote datavolumes.
- Acceptatietests: laten de opdrachtgever of de gebruiker beoordelen of de software doet wat is afgesproken.
Daarnaast bestaan er beveiligingstests, toegankelijkheidstests en verkennend testen. Bij dat laatste zoekt een tester zonder script naar gedrag dat niemand had bedacht. Niet elk project heeft alles nodig. Een intern hulpmiddel voor tien collega's vraagt iets anders dan een klantportaal met duizenden gebruikers.
Welke test zet je wanneer in
Een bruikbare vuistregel is de testpiramide: veel unittests, minder integratietests en nog minder tests die de hele applicatie via het scherm doorlopen. Hoe hoger je in de piramide komt, hoe trager en breekbaarder tests worden. Daarom zet je de meeste inspanning onderaan.
Koppel de soort test aan het moment in het traject:
- Tijdens het bouwen: unittests en integratietests, die de ontwikkelaar draait voordat de code wordt samengevoegd.
- Bij elke build: een compacte set regressietests, zodat je binnen minuten weet of er iets is gebroken.
- Voor een release: systeemtests en de belangrijkste gebruikersroutes, aangevuld met verkennend testen op de onderdelen die zijn gewijzigd.
- Voor een piek of livegang: performancetests met realistische aantallen gebruikers en realistische data.
- Vlak voor oplevering: acceptatietests door de mensen die de software straks gebruiken.
Kijk ook naar risico. Een betaalstap of een koppeling met een zorgsysteem verdient meer testwerk dan een tekstpagina. Schrijf op welke onderdelen je kritisch vindt, zodat de discussie over testdiepte niet bij elke release opnieuw begint. Dat scheelt tijd en voorkomt dat de deadline bepaalt hoeveel je test.
Handmatig of geautomatiseerd testen
Dit is geen keuze voor het een of het ander. Geautomatiseerde tests zijn sterk in herhaling: dezelfde controle bij elke build, zonder dat iemand er een middag aan kwijt is. Handmatig testen is sterk waar nieuwsgierigheid en oordeel nodig zijn, zoals bij een nieuw scherm, een onduidelijke foutmelding of een workflow die logisch moet aanvoelen.
In de praktijk is de onderste laag het vaakst geautomatiseerd. Volgens de enquête van ASQF e.V. uit 2024 had ruim driekwart van de deelnemers minstens driekwart van de unittests geautomatiseerd, terwijl bij hogere testniveaus ongeveer een derde zo ver was. Dat past bij het beeld dat unittests het makkelijkst te automatiseren zijn en dat het werk op integratie- en systeemniveau vaker blijft liggen.
Ook testen in de pipeline wint terrein. Volgens de RSE International Survey 2022 zette 46,97 procent (31 van 66) van de Nederlandse respondenten geautomatiseerd testen met continue integratie in, tegen 0 procent in 2018. Het gaat om een kleine groep respondenten, dus lees dit als signaal en niet als marktgemiddelde.
Wil je wijzigingen snel én veilig live zetten, dan heb je zulke geautomatiseerde tests nodig. Hoe een pipeline die snelheid mogelijk maakt, lees je in patchmanagement met CI/CD: updates in uren live.
Een teststrategie opstellen in vijf stappen
Een teststrategie hoeft geen document van veertig pagina's te zijn. Twee pagina's die het team ook echt leest, werken beter dan een map die niemand opent. Met deze stappen kom je er:
- Inventariseer risico's. Welke functies zijn bedrijfskritisch, welke veranderen vaak en waar zit de meeste complexiteit?
- Kies de niveaus. Bepaal per risico welk testniveau het beste past en schrap wat weinig oplevert.
- Bepaal wat je automatiseert. Begin met wat vaak draait en stabiel is: regressie van kernprocessen, API-tests en unittests. Automatiseer geen schermen die nog elke week veranderen.
- Leg release gates vast. Spreek af wanneer een build door mag, bijvoorbeeld als alle regressietests slagen en er geen blokkerende fouten openstaan.
- Evalueer na elke release. Welke fouten vond je pas in productie? Dat zijn de gaten in je strategie, dus vul ze aan.
Door dit in een vaste cyclus te doen, groeit je testaanpak mee met het product. Je test dan wat nu belangrijk is, en niet wat twee jaar geleden belangrijk was.
Kwaliteit begint voor de eerste regel code
Veel fouten ontstaan niet in de code maar in de vraag. Als niemand heeft vastgelegd wat de software moet doen bij een randgeval, bouwt de ontwikkelaar iets wat hij redelijk vindt en vindt de opdrachtgever later dat het niet klopt. Daarom hoort testen ook bij het beoordelen van requirements.
Wat helpt:
- Requirements reviewen voordat de ontwikkeling begint, met iemand die denkt als tester.
- Randgevallen vroeg benoemen: lege velden, dubbele invoer, tijdzones, grote bestanden en gebruikers met beperkte rechten.
- Acceptatiecriteria meetbaar maken. Schrijf dus niet dat de applicatie snel moet zijn, maar leg een reactietijd vast bij een afgesproken belasting. Hoe je dat in een contract zet, lees je in acceptatiecriteria vastleggen in je contract.
Zo wordt acceptatie aan het eind een beslissing in plaats van een discussie. Het scheelt ook herstelwerk, want een misverstand dat je bij de requirements vindt, kost veel minder dan hetzelfde misverstand in productie.
Wat je van een testpartner mag verwachten
Haal je externe hulp erbij, let dan op deze punten:
- Overdraagbare tests. Geautomatiseerde tests zijn code. Met schone code, duidelijke namen en een modulaire opbouw kan je eigen team ze uitbreiden zonder afhankelijk te blijven van de partij die ze schreef.
- Een strategie die bij je risico past. Geen standaardpakket, maar keuzes op basis van je releaseritme en wat er misgaat als iets faalt.
- Een heldere rol voor AI. AI kan testgevallen voorstellen, maar een QA-engineer beslist wat er in de testset komt.
- Eerlijke feedback. Een tester die alleen goed nieuws brengt, voegt weinig toe.
Bij Isatis valt dit onder kwaliteitsborging en testen: teststrategie en planning, testautomatisering en de kwaliteitsprocessen eromheen, zoals requirements reviewen, acceptatiecriteria vastleggen en release gates. We testen onze eigen software en die van anderen.
Veelgestelde vragen
Wat is het verschil tussen unittests en integratietests?
Een unittest controleert één klein onderdeel los van de rest, bijvoorbeeld een berekening. Een integratietest controleert of meerdere onderdelen samenwerken, zoals je applicatie met een database of een externe koppeling. Je hebt beide nodig, want een onderdeel kan op zichzelf kloppen en toch fout gaan zodra het met andere onderdelen praat.
Hoeveel van mijn tests moet ik automatiseren?
Er is geen vast percentage dat voor iedereen werkt. Automatiseer wat vaak terugkomt, stabiel is en veel risico dekt, zoals regressietests op kernprocessen en API-tests. Laat verkennend testen en beoordeling van nieuwe schermen bij mensen.
Wanneer begin je met testen?
Bij de requirements, dus voordat er code is. Je beoordeelt dan of de eisen duidelijk en toetsbaar zijn. Tijdens het bouwen volgen unit- en integratietests, en voor de oplevering de systeem- en acceptatietests.
Kan een extern team software testen die het niet zelf heeft gebouwd?
Ja. Dat kan goed werken, omdat een tester met een frisse blik ook aannames ziet die het bouwteam niet meer opvallen. Wel helpt het als je documentatie, testomgevingen en een aanspreekpunt beschikbaar maakt. Isatis test ook software van andere partijen.
Wil je weten welke tests bij jouw software passen, of twijfel je of je huidige aanpak genoeg dekt? Plan dan een kort gesprek van 15 minuten via de contactpagina. Je vertelt wat je wilt bereiken en wij zeggen eerlijk of we kunnen helpen.
Over de schrijver: Jeroen Penninx, Directeur en medeoprichter van Isatis.





