Als je een idee hebt voor een app, een website of een tool, loopt de weg van dat idee naar iets wat mensen gebruiken in een vrij vaste volgorde. Teams noemen de stappen verschillend. Belangrijker is dat elke stap eindigt met iets wat je kunt vastpakken: een schriftelijke afspraak, een tekening, een werkend scherm. Als niemand kan zeggen wat een stap oplevert, kan niemand zien of hij af is.
Hieronder staan vijf stappen in de volgorde waarin ze meestal gebeuren: waar elke stap voor is, wat je in handen moet hebben als hij eindigt, en de fouten die je het makkelijkst maakt.
Begrijp het probleem voordat er iets wordt getekend
Een project begint niet als iemand een designtool opent of de eerste regel code schrijft. Het begint met gesprekken over het probleem, een stap die meestal discovery heet, met de mensen die het product gaan gebruiken en de mensen die het gaan verkopen, ondersteunen of betalen.
De vragen zijn simpel. Wie heeft het probleem, en hoe gaat die er nu mee om? Wat zijn de grenzen: budget, deadline, regels, andere systemen waar het product mee moet samenwerken? En wat zou er na de lancering waar moeten zijn om het een succes te noemen?
Dit is de goedkoopste stap van de lijst, omdat van gedachten veranderen hier een gesprek kost. Dezelfde verkeerde aanname, ontdekt tijdens het bouwen, betekent werk dat opnieuw moet. Ontdekt na de lancering betekent het iets veranderen waar mensen al op vertrouwen.
Wat je aan het eind moet hebben
Een korte probleemstelling die zegt wie het probleem heeft en waarom het ertoe doet. De scope, dus wat de eerste versie wel en niet doet. De randvoorwaarden. En een omschrijving van succes die specifiek genoeg is om na de lancering te controleren.
Veelgemaakte fouten
Beginnen met een lijst features in plaats van een probleem. De stap overslaan omdat hij niets oplevert om naar te kijken. Succes zo vaag omschrijven ("mensen vinden het geweldig") dat niemand ooit kan zeggen of het gelukt is.
Verken de opties en kies er dan één
Als het probleem is afgesproken, maak je meerdere mogelijke antwoorden en kies je er één. Twee hulpmiddelen doen het meeste werk. Een user flow is de route die iemand stap voor stap door het product aflegt, van het openen tot het krijgen van waarvoor die kwam. Een wireframe is een ruwe indeling van een scherm in grijze blokken, zonder kleur of opmaak, zodat het gesprek gaat over wat waar komt en niet over hoe het eruitziet.
Houd dit werk met opzet ruw. Ruw werk gooi je snel weg, en dit is het laatste moment waarop een richting laten vallen bijna niets kost. Een schets is ook genoeg om aan een paar mogelijke gebruikers te laten zien en te ontdekken of ze begrijpen waar het product voor is.
Wat je aan het eind moet hebben
De belangrijkste user flows, wireframes van de belangrijkste schermen, en één gekozen richting met een korte geschreven reden. Die reden doet ertoe: een beslissing zonder reden wordt vaak teruggedraaid door de volgende die erbij komt en niet weet waarom hij is genomen.
Veelgemaakte fouten
Meteen naar gepolijste schermen springen, waardoor elke optie te af voelt om te laten vallen. Alleen het pad tekenen waarop alles goed gaat. Een richting kiezen zonder op te schrijven waarom.
Ontwerp hoe het eruitziet en hoe het werkt
Nu wordt de gekozen richting het echte ontwerp: de definitieve schermen, de visuele stijl, de woorden, en hoe elk onderdeel reageert als iemand het gebruikt. Vaak hoort daar een prototype bij, een klikbare mock-up die eruitziet als het product maar het echte werk erachter niet doet. Het is handig om met mensen te testen voordat er iets is gebouwd. Het is niet het product.
Een groot deel van deze stap is het ontwerpen van de situaties waar niemand als eerste aan denkt. Wat laat een scherm zien voordat er data in staat, de zogenoemde empty state? Wat laat het zien terwijl iets laadt, of als een betaling mislukt, of als er een fout in een formulier zit? Daar lopen mensen vast, en als het ontwerp ze niet afdekt, beslist iemand er later haastig over. Hoe een formulier iemand vertelt dat die een fout maakte laat zien hoeveel design er in één zo'n moment zit. Ook snelheid wordt hier bepaald: een scherm dat draait om een grote afbeelding wordt traag, wie het ook bouwt, en daarom is snelheid een designbeslissing.
Veel teams zetten nu ook een designsysteem op: gedeelde bouwstenen, zoals knoppen, formuliervelden, kleuren en tekststijlen, die zowel in het ontwerp als in de code worden gebruikt.
Wat je aan het eind moet hebben
Definitieve schermen voor elke belangrijke toestand, niet alleen de ideale. De tekst in het product. Een prototype dat echte mensen hebben geprobeerd, als je er een hebt gemaakt. En de bouwstenen waar de schermen van zijn gemaakt.
Veelgemaakte fouten
Het prototype behandelen als het afgewerkte product. Fouten, lege schermen en laden overlaten aan wie het bouwt, om die zelf te verzinnen. Een scherm ontwerpen dat er goed uitziet met voorbeeldinhoud en breekt met echte inhoud, zoals een naam die twee keer zo lang is als die in de mock-up.
Bouw het, met een tweede persoon die het werk leest
Bij het bouwen komt het ontwerp in aanraking met echte data, echte apparaten en echte netwerksnelheden, en een deel van wat vast leek te staan, blijkt dat niet te doen. Het ontwerpen is hier niet voorbij. Het wordt getest.
Meestal bouwen developers wat de designer heeft ontworpen, en blijven die twee met elkaar praten terwijl dat gebeurt; een bestand alleen draagt niet alles over, en daarom is een designbestand geen overdracht. Soms bouwt een designer delen zelf met AI-tools die code schrijven. Hoe dan ook moet iemand anders dan de maker het werk goed genoeg begrijpen om het te laten draaien. Een engineer die een ontwerp bouwt, leest het nauwkeurig en vraagt wat er gebeurt als het traag is, wat er gebeurt als het leeg is, en wie het repareert als het kapotgaat. Als de designer het werk ook zelf live zet, moet die tweede lezing bewust worden geregeld: meer over wat een team verliest als designers hun eigen code live zetten.
Wat je aan het eind moet hebben
Een werkend product in een testomgeving, een privékopie die echte klanten niet kunnen zien. Code die iemand anders dan de maker heeft gelezen. En een eigenaar met een naam, die wordt gebeld als het na de lancering kapotgaat.
Veelgemaakte fouten
De designer buiten het bouwen houden, alsof bouwen alleen het overnemen van het ontwerp is. Halverwege features toevoegen omdat elke feature klein lijkt. Code live zetten die maar één persoon begrijpt.
Lanceer, en kijk dan wat mensen doen
De lancering zet het product voor mensen die het niet hebben gemaakt. Alles tot dit punt is een reeks goed onderbouwde gissingen, en kijken naar echt gebruik maakt er kennis van.
Vergelijk met de omschrijving van succes uit de eerste stap. Kijk waar mensen aarzelen, opgeven of om hulp vragen. Een deel van wat je had gepland doet er niet toe, en iets waar je nooit op had gerekend wel.
Wat je aan het eind moet hebben
Een vergelijking van wat je verwachtte met wat er gebeurde, een korte lijst van wat je gaat veranderen, en een besluit over de volgende ronde.
Veelgemaakte fouten
De lancering zien als de finish en iedereen op iets anders zetten. Alleen tellen wat makkelijk te tellen is, zoals aanmeldingen, in plaats van het succes dat je had omschreven. Dingen veranderen vanwege één luide mening in plaats van wat je mensen zag doen.
Waar een project begint en ophoudt
Een project begint dus eerder dan de meeste mensen denken, met het gesprek over het probleem. En het houdt niet op bij de lancering: de lancering begint de volgende ronde, door dezelfde stappen op kleinere schaal.
Het aantal stappen doet er minder toe dan dit: bij elke stap kan iemand zeggen wat je in handen hebt als hij voorbij is. Daardoor kun je een project controleren terwijl het nog loopt, en niet pas als het al is afgelopen.