Versiebeheer voor ontwerpen, zonder developer te zijn
Developers hebben Git. Designers hebben ‘Homepage_FINAL_v4_revised_APPROVED.png’. Zo breng je orde in je ontwerpversies, zonder commandoregel.

Het kerkhof van bestandsnamen
Elke harde schijf van een designer vertelt hetzelfde verhaal:
Homepage_v1.png
Homepage_v2.png
Homepage_v2_revised.png
Homepage_FINAL.png
Homepage_FINAL_v2.png
Homepage_FINAL_FINAL_USE_THIS_ONE.png
Grappig, totdat een klant akkoord geeft op de verkeerde versie en jij de bestanden al naar de drukker hebt gestuurd.
Waarom versiebeheer voor ontwerpen lastig is
Developers hebben dit tientallen jaren geleden al opgelost met Git. Elke wijziging wordt bijgehouden en je kunt altijd terug, dus iedereen werkt vanuit dezelfde bron van waarheid. Maar de meeste tools voor versiebeheer van ontwerpen vragen technische kennis of binden je aan één specifieke ontwerpapp.
De praktijk voor de meeste freelancers en kleine bureaus:
- Bestanden staan in mappen met creatieve naamgeving.
- Klanten zien wat jij ze toevallig stuurt. Er is geen garantie dat ze naar de nieuwste versie kijken.
- Feedback raakt zijn context kwijt. De opmerkingen die een klant op v2 maakte, gaan niet mee als je v3 stuurt.
- Er is geen changelog. Als iemand vraagt “wat is er veranderd tussen ronde 2 en ronde 3?”, reconstrueer je de geschiedenis uit je geheugen.
Dit artikel laat zien waarom dat gebeurt en wat het je kost als het misgaat. Daarna lees je hoe je een versiegewoonte opbouwt waarvoor je geen commandoregel hoeft te leren.
Developerconcepten lenen, zonder commandoregel
Je hebt Git niet nodig om te profiteren van de ideeën erachter. Drie concepten zijn één op één over te nemen, en voor geen van alle hoef je ook maar één commando te typen.
Een versie is een momentopname, geen vervanging. In Git wist een commit de code van daarvoor niet uit. Hij voegt een nieuw punt toe aan de geschiedenis waar je altijd naar terug kunt. De ontwerpvariant is simpel: elke ronde die je naar een klant stuurt, is een eigen momentopname, bewaard naast de eerdere en niet eroverheen opgeslagen. Overschrijf je Homepage_FINAL.png met je laatste wijzigingen, dan kun je de vraag “hoe zag ronde 2 er eigenlijk uit?” niet meer beantwoorden.
Een diff laat zien wat er veranderd is. Developers reviewen pull requests aan de hand van een diff: precies de regels die tussen de ene commit en de volgende veranderd zijn. Designers krijgen dat zelden kant-en-klaar, dus moet je het zelf maken. Dat kan zo simpel zijn als twee versies naast elkaar, of een korte notitie bij elke upload over wat er verschoven is. Het punt is hetzelfde: laat de klant niet zoeken naar wat er anders is. Laat het zien.
Een branch is een verkenningsronde die nog niet is geaccepteerd. Als een developer een branch opent, zegt hij: “dit is een voorstel, nog niet samengevoegd met de hoofdlijn.” Een ontwerpronde die nog loopt, is precies hetzelfde. Die hoort niet als de nieuwe standaard aan de klant gepresenteerd te worden totdat hij hem echt heeft bekeken en goedgekeurd. “Hier is een idee dat ik uitprobeer” door elkaar halen met “dit is het huidige goedgekeurde ontwerp” is een van de meest voorkomende manieren waarop teams uit het oog verliezen wat er nu echt geldt.
Hiervoor heb je geen Git-client, geen terminal en geen informaticaopleiding nodig. Wel moet je versies behandelen als een geschiedenis die je aanvult in plaats van één bestand dat je steeds overschrijft, en heb je een manier nodig om zichtbaar te maken wat er tussen versies veranderd is.
Wat er gebeurt als versiebeheer faalt
Dit zijn geen hypothetische gevallen. Dit is een gewone dinsdag.
De klant geeft akkoord op de verkeerde versie. Je stuurt maandag een reviewlink. Woensdag heb je een revisie geüpload, maar de klant opent de oude link die hij als bladwijzer had opgeslagen, de link die nog naar v1 wijst. Hij antwoordt “Akkoord!” en jij zet het live. Twee weken later, in een launchmeeting, vraagt iemand waarom de hero nog de oude kop heeft. Nu doe je noodrevisies op een “afgerond” project, en de klant zweert dat hij op díe versie nooit akkoord heeft gegeven.
De designer overschrijft het goedgekeurde bestand. Je ruimt je projectmap op en slaat de laatste ronde aanpassingen op over het eerder goedgekeurde bestand. Het probleem: die goedgekeurde versie was degene waar de klant akkoord op gaf, en die heb je niet meer. Als de klant later een wijziging betwist (“die kleur heb ik nooit goedgekeurd”), heb je geen bewijs. Het akkoord is weg, omdat het bestand waar het bij hoorde niet meer in de oorspronkelijke vorm bestaat.
Feedback raakt kwijt tussen versies. Een klant zet uitgebreide opmerkingen bij v2: “zet de CTA hoger”, “wissel de achtergrondfoto”, “maak de subkop korter”. Je neemt die notities mee, bouwt v3 en stuurt die als nieuwe bijlage in een nieuwe mailthread. De klant opent v3 maar weet niet meer wat hij oorspronkelijk vroeg. Hij vraagt opnieuw om wijzigingen die je al hebt gedaan, of hij denkt dat je zijn opmerkingen hebt genegeerd. Ondertussen ligt de oorspronkelijke feedback zeventien berichten diep begraven in een thread waar niemand doorheen wil scrollen.
Twee mensen bewerken tegelijk en niemand merkt het. In een klein team gebeurt het vaak dat een designer en een junior collega, of een designer en een marketeer die nog wat aan de tekst schaaft, binnen een uur allebei hetzelfde bronbestand openen. Wie als laatste opslaat, wint, zonder dat iemand het merkt, en de wijzigingen van de ander zijn weg zonder enige waarschuwing dat er een conflict was. Developers krijgen merge-conflicten expliciet te zien. Designers zijn hun werk meestal gewoon kwijt.
Al deze problemen hebben dezelfde oorzaak: er bestaan versies, maar niets verbindt ze. De bestanden zweven op de ene plek, de feedback en beslissingen op een andere. Dat is wat echt versiebeheer oplost. Het houdt niet alleen bestanden bij, het verankert het hele gesprek aan de juiste momentopname.
Waarom de versiegeschiedenis van je ontwerptool niet genoeg is
Werk je in Figma, Adobe XD of gewoon Google Drive, dan heb je waarschijnlijk al een vorm van versiegeschiedenis. Het is verleidelijk om aan te nemen dat dat volstaat. Meestal is dat niet zo, en het gat doet er juist bij klantwerk toe.
Het is gemaakt voor wie bewerkt, niet voor de klant. De versiegeschiedenis van Figma is een scrollbare lijst met herstelpunten voor jou, degene die het bestand bewerkt. Er wordt van uitgegaan dat de kijker de tool al kent. Een klant die voor het eerst een Figma-bestand opent om “de versie van vorige dinsdag” te zoeken, is geen realistische vraag, zeker niet bij een klant die Figma nooit heeft gebruikt en nooit zal gebruiken.
Het legt geen beslissing vast. Ingebouwde versiegeschiedenis houdt bij dat een bestand veranderd is. Niet dat een klant ernaar keek en ja of nee zei. Een oude versie terugzetten vertelt je wat er in het bestand stond. Het vertelt niets over of iemand het goedkeurde, wanneer, of met welke afspraak.
Het werkt niet over bestandstypen heen. Eén project bestaat vaak uit een homepage-mockup, een pdf-voorstel, een korte walkthrough-video en een staging-URL waar de klant doorheen kan klikken. De geschiedenis van Figma dekt het Figma-bestand. Die van Drive dekt wat er in Drive staat. Geen van beide geeft je één plek waar een klant alle vier kan reviewen, met één consistent overzicht van wat wanneer is goedgekeurd.
Het verdwijnt als de klant geen bewerker is. De meeste ontwerptools tonen de volledige versiegeschiedenis alleen aan mensen met bewerkrechten. Klanten zijn meestal kijkers, als ze al toegang hebben, dus de geschiedenis waar je bij een discussie naar zou verwijzen, kunnen ze vaak zelf niet zien of exporteren.
Ingebouwde versiegeschiedenis blijft een prima vangnet voor je eigen bewerkingen. Het lost alleen een ander probleem op dan waar dit artikel over gaat: zorgen dat klant en designer altijd naar dezelfde momentopname kijken.
Praktisch versiebeheer zonder gedoe
1. Uploaden, niet vervangen
Overschrijf een bestand niet, maar upload de nieuwe versie naast de oude. Zo blijft de geschiedenis bewaard en kan iedereen versies vergelijken.
2. Koppel feedback aan versies
De grootste pijn bij versiebeheer zit niet in de bestanden. Die zit in de feedback. Staan opmerkingen in mail of Slack, dan raken ze los van de specifieke versie waar ze over gaan.
Aligno lost dit op door opmerkingen aan specifieke versies te koppelen. Upload je een nieuwe versie, dan blijven eerdere opmerkingen gekoppeld aan de versie waarop ze zijn achtergelaten. De klant ziet altijd de nieuwste versie, maar de volledige geschiedenis is één klik verwijderd.
3. Maak “actueel” ondubbelzinnig
Welke tool je ook gebruikt, er moet één versie duidelijk als “actueel” gemarkeerd zijn. Niet raden, niet vragen “is dit de nieuwste?”
4. Laat de klant altijd op de nieuwste versie uitkomen
Deellinks horen standaard altijd de meest recente versie te openen. Heeft de klant de reviewlink drie weken geleden als bladwijzer opgeslagen, dan moet die nog steeds laten zien wat nu actueel is, niet wat actueel was toen je hem voor het eerst deelde.
5. Sluit elke versie af met een beslissing
Versiebeheer gaat over meer dan bestanden bijhouden. Het houdt ook beslissingen bij. Elke versie die je naar een klant stuurt, hoort te eindigen met een expliciete actie: akkoord, of wijzigingen aangevraagd. Zonder dat blijf je gissen. Betekende stilte dat ze het mooi vonden? Hebben ze de link überhaupt geopend?
Sluit elke versie af met een vastgelegde beslissing, dan krijg je een audittrail die beide kanten beschermt. De klant kan niet beweren dat hij ergens nooit akkoord op gaf. Jij kunt niet per ongeluk doorwerken aan een versie die al was goedgekeurd. En als een project halverwege naar een andere designer gaat, ziet die precies waar het staat zonder iemand iets te hoeven vragen.
Kies een tool waarin klantakkoord in de reviewflow zit ingebouwd. De klant hoort akkoord te geven met een knop op het ontwerp zelf, in plaats van via een vervolgmail die later niemand meer kan vinden. Zo staat het akkoord direct naast de versie waar het over gaat.
Verschillende bestandstypen vragen om verschillende versiegewoonten
“Versiebeheer voor ontwerpen” wordt vaak besproken alsof elk project één statische afbeelding is. In de praktijk beslaat een ontwerp- of bureauproject meestal meerdere soorten bestanden, elk met zijn eigen eigenaardigheden qua versies.
Statische afbeeldingen en mockups
Dit is het eenvoudigste geval, en ook waar de meeste chaos met bestandsnamen vandaan komt. De gewoonte die je wilt aanleren is klein: elke export wordt geüpload als nieuwe versie van hetzelfde bestand, niet als nieuw bestand in een nieuwe map. Opmerkingen die op een specifieke plek op versie 2 zijn gepind (bijvoorbeeld een opmerking over de plaatsing van het logo), horen op versie 2 te blijven staan, ook als versie 3 er al is, zodat iedereen die terugkijkt precies ziet waar de opmerking over ging.
Pdf's van meerdere pagina's
Pdf's voegen een complicatie toe: feedback gaat meestal over een specifieke pagina. Een opmerking over de prijstabel op pagina 4 moet gekoppeld blijven aan pagina 4 van die specifieke versie, niet aan het document als geheel. Behandelt je reviewtool een voorstel van 12 pagina's als één plat bestand, dan krijg je opmerkingen die alleen kloppen als je nog weet welke pagina de reviewer open had toen hij ze schreef.
Videomontages
Video voegt naast versies ook een tijdsdimensie toe. “Fix de overgang” zegt niets zolang je niet weet over welke seconde van welke montage het gaat. Opmerkingen op video moeten aan een tijdstempel worden vastgepind, en die tijdstempel moet met de juiste versie meereizen, want na een nieuwe montage valt een bepaald moment al snel op een ander punt. Een tool die opmerkingen op een tijdstempel in video ondersteunt, lost een echt, apart probleem op naast het pinnen van een opmerking op een statische afbeelding.
Live webpagina's
Een webpagina op een stagingomgeving reviewen is weer anders, omdat het “bestand” een live URL is die op elk moment onder de reviewer kan veranderen. Een klant die maandag een staginglink opent en donderdag terugkomt, ziet misschien een compleet andere pagina als jij steeds wijzigingen naar dezelfde URL hebt gepusht, zonder te kunnen zien waar hij oorspronkelijk op reageerde. De oplossing volgt hetzelfde principe als overal: leg elke ronde wijzigingen aan die URL vast als eigen reviewbare versie, zodat een opmerking over de layout van maandag op donderdag nog steeds klopt, ook als de live pagina allang verder is.
Een uitgewerkt voorbeeld: drie rondes voor een nieuwe homepage
Concepten zijn makkelijker toe te passen met een concreet voorbeeld. Stel, je bent freelancer en ontwerpt in drie rondes een nieuwe homepage voor een klant.
Ronde 1. Je uploadt het eerste concept als versie 1 en deelt de reviewlink. De klant pint drie opmerkingen: de hero-afbeelding voelt generiek, de call-to-action-knop is te klein en in de footer moeten de juiste social links. Geen akkoord. Prima, daar is ronde 1 voor.
Ronde 2. Je verwerkt alle drie de opmerkingen en uploadt versie 2. Omdat de opmerkingen van versie 1 nog aan versie 1 gekoppeld zijn, kunnen jij (en de klant) terugscrollen en elk punt afvinken tegen wat er veranderd is, in plaats van op je geheugen te vertrouwen. De klant bekijkt versie 2, is blij met de richting, maar vraagt nog één aanpassing: de nieuwe hero-afbeelding is goed, maar de uitsnede klopt niet op mobiel. Nog steeds geen akkoord, en dat is verwacht en normaal.
Ronde 3. Je past de uitsnede aan en uploadt versie 3. Deze keer klikt de klant op akkoord. Die beslissing wordt vastgelegd op specifiek versie 3, met een tijdstempel. Als iemand aan de kant van de klant twee maanden later vraagt wie de hero-sectie heeft goedgekeurd, is er een direct antwoord: deze versie, deze datum, deze beslissing, zonder dat iemand iets hoeft te onthouden.
Kijk wat dit werkbaar maakte: niets werd overschreven, elke feedbackronde bleef gekoppeld aan de versie waar die over ging, en het akkoord aan het eind wees naar een exacte, nog bestaande momentopname in plaats van naar “wat er nu live staat”.
Je hebt geen Git nodig
Je hebt een systeem nodig dat versies bijhoudt en de feedback eraan gekoppeld houdt, zodat iedereen weet welke versie de versie is die telt. Houd het simpel en visueel, en je toekomstige zelf zal je dankbaar zijn.
Groei je uit je huidige reviewtool? Bekijk dan hoe Aligno zich verhoudt tot GoVisually voor design review met versiebeheer, of bekijk het volledige overzicht van functies om te zien hoe versies, opmerkingen en akkoord op één plek samenkomen.