Git en versiebeheer: elke wijziging terug te draaien
In dit artikel
Versiebeheer met Git houdt van elke wijziging aan je website bij wat er veranderde, wanneer en waarom. Daardoor is elke wijziging terug te draaien, ook één losse aanpassing van weken geleden, zonder dat de rest van de site verandert. De geschiedenis staat online, bijvoorbeeld bij GitHub, op een account dat van jou hoort te zijn. Formuliergegevens en databases staan er niet in; die regel je apart. Voor mij is versiebeheer de basis onder elke wijziging die ik voor een klant doorvoer.
Wat is versiebeheer met Git?
Versiebeheer is een logboek van alles wat er aan je website verandert. Git is het programma dat dat logboek bijhoudt. Bij elke wijziging legt Git vast welke bestanden anders zijn, wat er precies is veranderd, wie het deed en wanneer. En waarom: dat staat in een korte omschrijving die de maker er zelf bij schrijft.
Vergelijk het met 'Wijzigingen bijhouden' in Word, maar dan voor een hele website en zonder dat alles vol rode strepen komt te staan. Je werkt gewoon in de nieuwste versie. Wie wil, kan elke eerdere versie terughalen, ook die van twee jaar geleden.
Git is in 2005 gemaakt door Linus Torvalds en de ontwikkelaars van Linux, om het werk van duizenden programmeurs aan één project bij te houden. Het is gratis, open source en inmiddels het standaardgereedschap van vrijwel elke ontwikkelaar. Het werkt het best bij een site waarvan alles in losse bestanden staat: teksten, vormgeving en code. Zo zijn mijn maatwerksites opgebouwd, met die hele map in versiebeheer. Wat voor bestanden dat zijn, laat ik zien in Markdown, YAML en JSON.
Je hoeft Git niet te kunnen bedienen om er iets aan te hebben. Het is gereedschap voor je bouwer. Wat jij moet weten, is wat het je oplevert en waar je op let als iemand anders je site maakt of beheert.
Waarom versiebeheer de basis van mijn werkwijze is
Een vastgelegde wijziging heet een commit. Zie het als een foto van de hele projectmap op dat moment, met een onderschrift. Git bewaart ook het verschil met de vorige foto: welke regels zijn weggehaald en welke erbij zijn gekomen. Dat verschil heet een diff.
Bij mij loopt elke wijziging aan je site via dat logboek. Elke wijziging leg ik vast in Git met een omschrijving in gewone taal, ook de kleinste correctie. Een voorbeeld van hoe zo'n geschiedenis eruit kan zien:
12 nov Openingstijden rond de feestdagen toegevoegd op de contactpagina
11 nov Nieuwe vacature voor assistent geplaatst op werken-bij
08 nov Telefoonnummer tweede locatie aangepast in het locatiebestand
05 nov Foto's op de teampagina vervangen en kleiner gemaakt
Het onderschrift maakt het verschil tussen een bruikbaar logboek en een onleesbare lijst. Omschrijvingen als 'update' of 'fix' zeggen over een jaar niemand meer iets. Een goede omschrijving beantwoordt twee vragen: wat is er veranderd, en waarom. Het waarom mag in een regel eronder, bijvoorbeeld 'op verzoek van de klant, geldig tot 2 januari'.
Dat logboek is ook van jou. Je kunt altijd meekijken wat er is gebeurd. En wie later aan je site werkt, ziet precies hoe hij is opgebouwd en waarom.
Wat er misgaat zonder versiebeheer
Veel websites worden nog bewerkt zonder logboek: rechtstreeks op de server, via een bestandsprogramma of in een systeem dat alleen de laatste versie bewaart. Dat gaat goed tot er iets stukgaat. Dan blijkt wat je mist:
- Niemand weet wat er veranderd is. Het menu werkt niet meer, maar welke aanpassing dat veroorzaakte, moet iemand uitzoeken. Dat kost uren in plaats van minuten.
- Terug kan alleen naar de laatste back-up. Daarmee ben je ook alle goede wijzigingen kwijt die na die back-up zijn gedaan.
- Niet te achterhalen wie wat deed. Werken er meerdere mensen of partijen aan de site, dan is achteraf niet te zeggen wie welke aanpassing heeft gedaan.
- Een nieuwe bouwer begint blind. Zonder geschiedenis moet hij eerst uitzoeken hoe alles in elkaar zit, voordat hij iets durft aan te raken.
Een CMS als WordPress bewaart wel eerdere versies van een tekst, maar doorgaans niet van plugins, hun instellingen of de code van het thema. Juist daar zitten de wijzigingen die een site kunnen breken.
Elke wijziging terug te draaien: wat dat voor jou betekent
Het grootste voordeel van versiebeheer is dat niets definitief kwijt is. Drie situaties komen vaak voor:
| Situatie | Wat Git doet | Wat je ervan merkt |
|---|---|---|
| Eén wijziging bleek een vergissing | Maakt een nieuwe commit die precies die wijziging ongedaan maakt | Latere wijzigingen blijven staan, alleen die ene verdwijnt |
| Een tekst was vorige maand beter | Haalt één bestand terug uit een eerdere versie | De rest van de site blijft zoals hij is |
| Je wilt weten wanneer iets veranderde | Zoekt in de geschiedenis wie welke regel wanneer aanpaste | Je krijgt de datum en de omschrijving van die wijziging |
Let op het verschil met de prullenbak op je computer. Bij terugdraaien wordt er niets uit de geschiedenis gewist. Git voegt een nieuwe stap toe die de oude ongedaan maakt. Ook het terugdraaien zelf is dus later terug te vinden, met een omschrijving erbij.
Terugdraaien klinkt eenvoudig, maar vraagt overzicht. Soms hangt een latere wijziging af van de wijziging die terug moet, bijvoorbeeld een nieuwe pagina die ook in het menu is gezet. En terugdraaien in Git is nog iets anders dan de live site terugzetten: daarna moet de site opnieuw gebouwd en gepubliceerd worden. Die stap van vastleggen naar live beschrijf ik in wat is deployen. Dat soort afwegingen maak ik voor je. Jij zegt wat terug moet, ik zorg dat de rest blijft werken.
Grotere klussen op een zijspoor
Kleine wijzigingen, zoals een nieuwe openingstijd of een tikfout, gaan rechtstreeks op de hoofdlijn van het project. Die hoofdlijn heet meestal main. Wat daar staat, is wat er live staat.
Voor grotere klussen bestaat een branch: een zijspoor waarop gewerkt kan worden zonder dat de hoofdlijn verandert. Denk aan een nieuwe dienstenpagina met eigen vormgeving, een ander menu of de koppeling met een afsprakensysteem. Op de branch kan dagen of weken gebouwd en uitgeprobeerd worden. Ondertussen gaan kleine wijzigingen op de hoofdlijn gewoon door.
Is de klus af en goedgekeurd, dan gaat de branch op in de hoofdlijn. Dat heet mergen. Git zet de nieuwe onderdelen erbij en laat de tussentijdse wijzigingen op de hoofdlijn intact. Blijkt de klus toch geen goed idee, dan blijft de branch liggen en heeft de live site er nooit iets van gemerkt.
Veel statische hosts maken van een branch automatisch een voorbeeldversie op een eigen adres. Dat sluit aan op hoe ik met grotere wijzigingen omga: die bekijk je eerst op zo'n proefadres, en pas na jouw akkoord gaan ze naar de live site. Wat zo'n proefomgeving verder inhoudt, staat in staging-omgeving.
Git, GitHub en de vraag van wie de code is
De namen lijken op elkaar en worden door elkaar gebruikt. Toch is het verschil belangrijk, zeker als het gaat om wie waar eigenaar van is.
| Wat het is | Waar het draait | Kosten (stand november 2026) | |
|---|---|---|---|
| Git | Het programma dat de geschiedenis bijhoudt | Op de computer van de maker | Gratis, open source |
| GitHub | Online opslag voor projecten met Git, van Microsoft | In de cloud | Gratis versie met onbeperkt aantal privéprojecten; Team $ 4 per gebruiker per maand |
| GitHub Desktop | App om met Git te werken zonder commando's te typen | Op Windows en macOS | Gratis, open source |
Git werkt zonder GitHub, maar dan staat de geschiedenis alleen op de computer van de maker. GitHub bewaart een volledige kopie online, inclusief alle eerdere versies. GitLab en Bitbucket doen hetzelfde. GitHub Desktop laat in een overzichtelijk venster zien welke bestanden veranderd zijn en welke omschrijving bij elke stap hoort; volgens de documentatie van GitHub werkt het ook met projecten bij andere diensten. Kort gezegd: Git houdt bij, GitHub bewaart, GitHub Desktop laat het zien.
Een project in Git heet een repository, vaak afgekort tot repo. De belangrijkste vraag voor een ondernemer is niet hoe Git werkt, maar op wiens account die repository staat. Staat hij alleen op het account van de bouwer, dan ben je afhankelijk van zijn medewerking. Hoe vervelend dat kan uitpakken, lees je in webbouwer reageert niet meer. Daarom zet ik de repository van een site die ik bouw op jouw account, of geef ik je er volledige toegang toe. Dan hangt de geschiedenis van je site niet aan mijn medewerking.
Waar je bouwer verder op moet letten:
- Tweestapsverificatie op het account, zodat een gestolen wachtwoord niet genoeg is om binnen te komen.
- Geen wachtwoorden of sleutels in de repository. Die horen in de instellingen van de hosting. Wie toegang heeft, ziet alles, ook in oude versies. Een wachtwoord dat er ooit in heeft gestaan, is met weghalen niet weg; het moet worden vervangen.
- Documentatie in de repository zelf: hoe de site gebouwd wordt, welke diensten eraan gekoppeld zijn en waar de accounts staan. Dan kan een andere ontwikkelaar het werk overnemen. Wat er bij zo'n overdracht allemaal mee moet, staat in website overdracht.
Waarom Git een deel van je back-up is, maar niet alles
Bij een site die als bestanden in versiebeheer staat, is de repository een goede back-up van de site zelf. De hele geschiedenis staat online en op elke computer waar het project op staat. Gaat er bij de hosting iets mis, dan is de site vanuit de repository opnieuw te bouwen en op een andere plek te publiceren.
Maar Git bewaart alleen wat in de projectmap staat. Wat bezoekers op de site achterlaten, staat ergens anders. Een voorbeeld uit de praktijk: bij een tandartspraktijk met twee locaties gaan inschrijvingen van nieuwe patiënten versleuteld naar een aparte opslag bij de hosting, Netlify Blobs. Die inschrijvingen staan dus niet in Git, en dat is de bedoeling. Persoonsgegevens horen niet in een codeproject. Voor zulke gegevens zijn aparte afspraken nodig over opslag, bewaartermijn en wie erbij kan. Daarover gaat gevoelige gegevens via je websiteformulier.
| Onderdeel | Staat het in Git? | Wat moet apart geregeld worden? |
|---|---|---|
| Code, vormgeving en teksten in bestanden | Ja, met de hele geschiedenis | Niets, zolang de repository online bewaard wordt |
| Afbeeldingen en video's in de projectmap | Meestal wel | Heel grote bestanden soms in aparte opslag |
| Formulierinzendingen en aanmeldingen | Nee | Opslag, bewaartermijn en toegang bij de dienst die ze ontvangt |
| Database van een WordPress-site | Nee | Een eigen back-up van database en uploads |
| Instellingen van hosting, domein en DNS | Nee | Een overzicht in de documentatie |
| Wachtwoorden en API-sleutels | Horen er niet in | Een wachtwoordmanager en de instellingen van de hosting |
Bij WordPress staan de teksten in een database en niet in bestanden. Git helpt daar alleen voor het thema of een eigen plugin. Voor de rest is een gewone back-up nodig, zoals beschreven in WordPress backup maken.
Versiebeheer en AI: de basis van de controle
Het typwerk aan de sites die ik bouw, laat ik doen door een codeer-agent. Versiebeheer is daarbij geen extraatje, maar de basis van mijn controle. In de diff zie ik precies welke regels de agent wil veranderen, nog voordat er iets wordt vastgelegd. Wijzigt hij meer dan gevraagd, dan valt dat meteen op. En klopt er achteraf iets niet, dan is die ene wijziging terug te draaien zonder dat de rest van de site er last van heeft.
Dat bedoel ik met mét AI, niet dóór AI. Zonder versiebeheer zou ik een agent niet aan een klantsite laten werken. Hoe zo'n ronde van verzoek tot livegang verloopt, volg je in website aanpassen met AI. Waar ik op let bij het nakijken van wat een agent maakt, staat in AI-code controleren.
Ook de bouwafspraken voor de agent, zoals huisstijl, schrijfregels en wat nooit mag, staan als bestand in de repository. Verandert er een afspraak, dan is dat terug te zien in de geschiedenis. Wat er in dat bestand staat, laat ik zien bij bouwafspraken voor je codeer-agent.
Conclusie: versiebeheer maakt elke wijziging controleerbaar en omkeerbaar
Versiebeheer met Git legt elke wijziging aan je website vast met een omschrijving, een datum en het precieze verschil. Daardoor kan elke wijziging terug, worden grotere klussen veilig op een zijspoor gebouwd en is altijd te zien wie wat heeft gedaan. Voor jou betekent dat: geen giswerk als er iets misgaat, geen afhankelijkheid van één persoon en een site die altijd terug te halen is. Formuliergegevens en databases vragen wel een eigen regeling.
Zo werk ik aan elke site die ik beheer: elke wijziging in gewone taal vastgelegd, de repository van jou of voor jou toegankelijk, en elke stap terug te draaien. Jij hoeft er niets van te leren. Wil je weten hoe een vastgelegde wijziging daarna op je live site komt, lees dan wat is deployen. Benieuwd hoe ik verder werk? Download het pitchdeck.
Veelgestelde vragen
Wat is het verschil tussen Git en GitHub?
Git is het programma dat de geschiedenis van een project bijhoudt: elke wijziging met een omschrijving, een datum en het precieze verschil. Het draait op de computer van de maker. GitHub is een online dienst van Microsoft waar projecten met Git worden bewaard en gedeeld. Zonder GitHub of een vergelijkbare dienst staat de geschiedenis alleen op die ene computer. Met zo'n dienst is er een volledige kopie online en is per persoon te regelen wie toegang heeft. GitLab en Bitbucket doen hetzelfde. Voor jou als ondernemer telt vooral dat die online kopie op jouw naam staat.
Is GitHub gratis?
Voor de meeste websites wel. De gratis versie van GitHub heeft een onbeperkt aantal openbare en privéprojecten, stand november 2026, en je kunt daarin anderen toegang geven, zoals je bouwer of beheerder. Betaalde abonnementen, zoals Team voor $ 4 per gebruiker per maand, voegen vooral functies toe voor teams en organisaties. De moeite zit dus niet in de dienst, maar in het goed inrichten: wie is eigenaar, wie heeft toegang en hoe is het account beveiligd.
Kan ik met Git een oude versie van mijn website terugzetten?
Ja, als de site in versiebeheer staat. Git bewaart elke vastgelegde versie, dus een losse wijziging, één bestand of het hele project kan terug naar een eerder moment. Daarbij wordt niets gewist: Git voegt een nieuwe stap toe die de oude omkeert. Daarna moet de site opnieuw gebouwd en gepubliceerd worden. Het vraagt wel overzicht, want soms hangen latere wijzigingen af van de wijziging die terug moet. Daarom is het werk voor je beheerder. Formuliergegevens of een database zet je met Git niet terug, want die staan er niet in.
Moet ik zelf Git leren als mijn webbouwer het gebruikt?
Nee. Git is gereedschap voor je bouwer, zoals een boekhoudpakket gereedschap is voor je boekhouder. Voor jou telt dat het er is, dat elke wijziging een begrijpelijke omschrijving krijgt en dat de repository op jouw naam staat of dat je er volledige toegang toe hebt. Jij geeft door wat er moet veranderen; het vastleggen in Git doe ik. Wil je zien wat er is gebeurd, dan kun je altijd meekijken in de geschiedenis.
Benieuwd hoe ik dit in de praktijk aanpak?
Het pitchdeck laat de hele werkwijze zien.
Geschreven door Dennis Boekhout
Marketing freelancer uit 's-Hertogenbosch. Volg op LinkedIn (opent in een nieuw tabblad)
