M365Con 2027 – gratis online conferentie · 11–22 Jan 2027 · 120 sessions→ m365con.net

Blog · Mirko Peters

Van manuele tester naar automatiseringsengineer: een realistisch eerste kwartaal

By · · Updated

Van manuele tester naar automatiseringsengineer: een realistisch eerste kwartaal met drie fasen, één taal en framework, een eerste regressiesuite en de rol van AI-tools.

Automatically translated with AI from the original post. Read the English original

De overstap van manuele tester naar automatiseringsengineer is kleiner dan het lijkt, en ze duurt langer dan een cursus van een weekend doet vermoeden. Deze gids is bedoeld voor manuele testers en QA-leads die een plan willen voor de eerste drie maanden van een loopbaan in softwaretesten en testautomatisering. Je ziet wat er in de rol verandert, een kwartaal in drie fasen, hoe je een taal en een eerste project kiest, welke regressiecontroles je eerst automatiseert en waar AI-tools helpen. Een uitgewerkt voorbeeld met fictieve cijfers laat het kwartaal van één tester zien.

Belangrijkste punten

  • Je testoordeel is het lastige deel van de overstap naar automatisering; de code is aan te leren. Het eerste kwartaal draait dus vooral om het opbouwen van de gewoonte om kleine, betrouwbare controles te schrijven.
  • Een realistisch eerste kwartaal bestaat uit drie fasen: de basis en één tool, een eerste kleine suite op een echte applicatie, en daarna een pipelinerun plus een korte beschrijving van wat je hebt gebouwd.
  • Kies één taal en één framework, bijvoorbeeld Python of JavaScript met Selenium of Playwright, en rond eerst een project af voordat je tools vergelijkt.
  • Begin met een handvol stabiele, herhaalde regressiecontroles, omdat onderhoud net zoveel tijd kan kosten als het schrijven van nieuwe tests.
  • AI-assistenten kunnen testcode opstellen op basis van user stories, maar je hebt de basis nog steeds nodig om te beoordelen wat ze produceren.

Wat er in de rol echt verandert

De PractiTest-gids over het worden van een geautomatiseerde tester maakt een punt dat je het best vooraan zet: automatisering is nog steeds testen. Goed testontwerp is belangrijker dan de keuze van de tool, want een tool test alleen wat je het laat testen. Je gewoontes als manuele QA-tester, zoals het opmerken van vreemd gedrag, nadenken over grenswaarden en je afvragen wat er mis kan gaan, zijn het deel dat je niet uit een tutorial haalt.

Wat verandert, is de eenheid van werk. In plaats van een testcase uit te voeren, schrijf je een klein programma dat de test uitvoert, en daarna houd je dat programma werkend. Dezelfde gids verwacht dat je veel tijd besteedt aan probleemoplossing, vooral aan het bepalen of een fout komt van het script, de omgeving of een echte defect. Geautomatiseerde tests zijn bovendien vooral bevestigend. Ze fungeren als vangnet, dus veel geslaagde resultaten zijn normaal, en de nuttige vraag is of je controles niet te makkelijk zijn.

Er is nog een verandering die je makkelijk over het hoofd ziet. Je wordt verantwoordelijk voor code waar anderen van afhankelijk zijn. Een controle die zonder reden faalt, kost het hele team tijd en vertrouwen, dus betrouwbaarheid is belangrijker dan het aantal controles.

Van manuele tester naar automatiseringsengineer: de eerste 90 dagen

De bronnen zijn het niet eens over één schema, dus het onderstaande plan is ons eigen voorstel, gebaseerd op hun adviezen. Het gebruikt drie fasen van ongeveer een maand elk.

Fase 1, weken 1 tot 4: basis en één tool.

  • Leer automatiseringsvaardigheden in kleine stappen, niet allemaal tegelijk.
  • Inventariseer je handmatige werk. Noteer wat je het vaakst herhaalt en hoelang elke run duurt.
  • Leer de basis van coderen in één taal: variabelen, besturingsstructuren, functies, lijsten en woordenboeken, een bestand lezen en fouten afhandelen. Eén gids over de overstap zet programmeerfundamenten voorop en beschrijft de maanden vóór de eerste test als voorbereiding.
  • Installeer Git en bewaar alles vanaf dag één in een repository.
  • Schrijf je eerste kleine scripts los van je product, bijvoorbeeld een logparser of een kleine dataGenerator. Zo blijven de eerste fouten goedkoop.

Fase 2, weken 5 tot en met 9: een eerste kleine suite op een echte applicatie.

  • Kies een framework voor testautomatisering en schrijf checks voor drie of vier kritieke flows, zoals inloggen, zoeken en afrekenen.
  • Gebruik een publieke demo-applicatie of een open-sourceproject als je eigen product nog niet geschikt is. PractiTest raadt aan te beginnen met een webapplicatie en mobiel testen voor later te laten, omdat dat lastiger is.
  • Organiseer de code vanaf het begin, bijvoorbeeld met page objects en duidelijke namen, zodat een wijziging in een pagina niet betekent dat je twintig tests moet aanpassen.

Fase 3, weken 10 tot en met 13: een pipeline en een logboek.

  • Laat de suite draaien vanuit een continuous integration-taak, zodat hij bij elke wijziging draait zonder dat je op een knop hoeft te drukken.
  • Schrijf een korte README: wat de suite dekt, hoe je hem draait en wat hij niet dekt.
  • Bekijk één week aan resultaten. Welke checks faalden zonder dat er een defect was? Repareer ze of verwijder ze.
  • Laat het werk zien aan een developer en vraag om een review. Alleen leren gaat traag, en die gids noemt leren in isolatie een fout.

Dezelfde gids beschrijft een plan van zes maanden met 10 tot 15 uur per week. Een kwartaal alleen maakt je dus nog geen senior engineer. Je krijgt wel een werkende suite, een gewoonte en een portfolio.

Kies één taal en één framework

Kies er één en rond er een project mee af.

  • Taal. De gids adviseert Python voor beginners en JavaScript of TypeScript voor moderne webstacks. Kies wat je developers gebruiken, zodat iemand je code kan reviewen en je vragen kan beantwoorden.
  • Browserframework. Selenium en Playwright worden in de bronnen het vaakst genoemd. De 90-dagenroadmap op DEV Community adviseert Playwright voor moderne webapps, Cypress voor snelle ontwikkeling en Selenium voor legacy-ondersteuning. Kies het framework dat je team al gebruikt, als er zo'n framework is.
  • Testrunner. Pytest voor Python of Jest voor JavaScript, zoals die gids aangeeft.

PractiTest voegt een nuttige leervolgorde toe: eerst algemene automatiseringsbenaderingen, die werken over tools en talen heen, en pas daarna een tool waar vraag naar is. Controleer de stack van je bedrijf en een paar vacatures voordat je beslist. Koop geen tool en reken erop dat de dekking vanzelf volgt. Dezelfde gids noemt denken vanuit de tool een valkuil.

Welke regressiechecks je als eerste automatiseert

Je handmatige regressielijst is de beste bron voor wat je als eerste automatiseert, omdat je al weet dat het de moeite waard is om te draaien. Het regressietesten dat je bij elke release herhaalt, is het deel dat een script het best aankan. De DEV Community-roadmap adviseert om in de eerste weken vijf kritieke gebruikersflows te kiezen en een smoke-suite te bouwen die bij elke deployment draait, als eerste snelle winst.

Kies checks die:

  • Stabiel zijn. De functionaliteit is al weken niet veranderd en verandert in de volgende sprint waarschijnlijk ook niet.
  • Herhaald worden. Je draait ze bij elke release of elke build.
  • Duidelijk zijn. Er is één verwacht resultaat dat je in één zin kunt formuleren.

Laat de rest voorlopig liggen. De gids is duidelijk dat exploratief testen en usability-testen niet geautomatiseerd moeten worden, en hij noemt "alles automatiseren" een fout. Een handvol betrouwbare checks is beter dan honderd fragiele, want zoals PractiTest waarschuwt, kan onderhoud net zoveel tijd kosten als het maken van nieuwe tests.

Een eerste suite van dit soort dekt meestal een paar browserflows van begin tot eind. Dit is end-to-endtesten in de eenvoudigste vorm: een script gedraagt zich als een gebruiker en controleert of een volledige workflow, zoals inloggen of afrekenen, nog werkt. Voeg API-testen toe wanneer een flow zonder browser getest kan worden, omdat die tests sneller draaien en minder vaak breken.

Waar AI-tools in het kwartaal passen

AI-assistenten kunnen het werk versnellen, maar ze vervangen de basis niet. De DEV Community-roadmap plaatst AI-ondersteunde testgeneratie pas na de eerste maand met fundamenten, en die volgorde is verstandig. Er wordt geadviseerd om testscenario's te genereren op basis van user stories, de uitvoer te vergelijken met handmatig geschreven code, en de assistent context te geven, zoals je page object-patroon en naamgevingsconventies. Ook wordt aangeraden de basis te begrijpen in plaats van volledig op AI te vertrouwen, en een zwakke handmatige teststrategie te verbeteren voordat je die automatiseert.

Je kunt niet beoordelen wat je niet begrijpt. Als je de gegenereerde test niet kunt lezen, weet je niet of hij het juiste controleert of alleen slaagt. Dat is onze eigen redenering, maar ze komt overeen met de volgorde in de bronnen. Gebruik de AI-assistent voor concepten en om onbekende code uit te leggen, maar houd de beslissingen over wat je test bij jezelf.

Zelfherstellende tools, die vaak AI gebruiken, zijn een verwant onderwerp. PractiTest waarschuwt dat ze gewijzigde locators kunnen herstellen, maar weinig doen als het proces in een test verandert. Zie ze als hulp bij onderhoud, niet als reden om een goed ontwerp over te slaan. Leren deze tools goed te gebruiken is onderdeel van AI upskilling: training gekoppeld aan een terugkerende taak, beoordeeld op hoe het werk verandert en niet op het aantal afgeronde cursussen.

Voorbeeld: het eerste kwartaal van één tester

De cijfers zijn verzonnen.

Een tester in een QA-team van acht personen voert vóór elke release een handmatige regressielijst van 80 cases uit. De run kost twee personen ongeveer anderhalve dag. Zij heeft geen programmeerachtergrond.

In week 1 tot en met 4 werkt zij ongeveer vijf uur per week aan de basis van Python en schrijft drie kleine scripts. Ze noteert ook welke 12 cases zij het vaakst uitvoert en welke al twee maanden niet zijn veranderd.

In week 5 tot en met 9 schrijft zij controles voor 9 van die 12 cases met Playwright, met page objects voor de aanmeld- en bestelpagina's. Twee controles falen willekeurig; zij herleidt beide tot timingproblemen en lost ze op. Een developer beoordeelt haar code en vraagt haar dubbele stappen te verwijderen.

In week 10 tot en met 13 draait zij de 9 controles bij elke merge vanuit een pipeline en schrijft zij een README van één pagina. De controles duren ongeveer zes minuten. De handmatige regressierun daalt van anderhalve dag naar ongeveer een dag, omdat 9 van de 80 cases gedekt zijn. Het plan voor het volgende kwartaal is 15 extra controles, en het besluit om verkennend testen handmatig te houden.

Veelgemaakte fouten

  • Alleen tutorials kijken zonder iets te bouwen. De transitiegids noemt dit tutorial hell en adviseert veel meer tijd te besteden aan doen dan aan kijken.
  • Basale codeervaardigheden overslaan. Meteen naar een framework springen zorgt ervoor dat je je eigen scripts niet kunt debuggen.
  • Alles willen automatiseren. Verkennend en gebruiksvriendelijkheidstesten blijven handmatig, en instabiele functies zijn slechte kandidaten.
  • Onderhoud negeren. Plan tijd in om controles te repareren en te verwijderen, niet alleen om ze te schrijven.
  • Blind vertrouwen op een geslaagde run. Scripts kunnen om de verkeerde reden slagen, dus kijk er af en toe naar terwijl ze draaien en laat ze bewust falen.
  • Alleen leren. Vraag om code review en zoek al vroeg een mentor of een community.

Hoe software kan helpen

Begin met gratis tools: een code-editor, Git, een openbare demo-applicatie en de ingebouwde runners van het framework dat je kiest. Een continuous integration-dienst draait de suite bij elke wijziging, en een eenvoudige trackinglijst kan je kandidaat-controles, hun status en de laatste reviewdatum bijhouden. Recorders en AI-assistenten kunnen testcode concipiëren, maar controleer elke regel. Als je team later een platform wil dat tests voor je beheert, vergelijk het dan met wat je zelf hebt gebouwd, en beoordeel het op hoeveel onderhoud het in de praktijk wegneemt.

Volgende stap

Schrijf de tien handmatige controles op die je het vaakst herhaalt en markeer de drie meest stabiele. Start deze week je plan van handmatig tester naar automation engineer door één taal en één framework te kiezen en de eerste van die drie controles te schrijven.

Entities in this article

End-to-end testing Regression testing AI upskilling

Related articles

RSS