Momenteel neem ik geen nieuwe klanten aan +31 6 301 963 14 dennis@gouwers.nl
Headless

Contentmodel: de inhoud van je website slim opbouwen

Bijgewerkt op 11 min leestijd

In dit artikel

Deel 13 van 20uit de reeks Headless website met een vaste beheerder

Een content model is de vaste opbouw van de inhoud van je website: welke soorten inhoud er zijn, zoals locaties, teamleden en vacatures, en uit welke velden elke soort bestaat. Elk gegeven staat dan op één plek en de site gebruikt het overal waar het nodig is. Dat voorkomt tegenstrijdige informatie en maakt wijzigingen met AI sneller en beter te controleren. De keuzes in zo'n model gaan jaren mee; in mijn projecten zet ik het op en houd ik het bij.

Wat is een content model?

Een content model is een afspraak over welke soorten inhoud je website heeft en uit welke vaste onderdelen elke soort bestaat. Die onderdelen heten velden: een naam, een datum, een foto, een telefoonnummer. Een soort inhoud met vaste velden heet een inhoudstype, bijvoorbeeld 'vacature', 'teamlid' of 'locatie'.

Vergelijk het met de kaartenbak van een huisarts van vroeger. Elke kaart heeft dezelfde vakjes: naam, adres, geboortedatum. Daardoor vind je alles snel terug en kun je de kaarten op elke manier sorteren. Een website zonder content model lijkt meer op een stapel losse brieven. Alles staat erin, maar je moet elke brief lezen om te vinden wat je zoekt.

In het Engels heet het werk content modelling. Het is geen software, maar een ontwerp van je inhoud dat daarna wordt vastgelegd: in een CMS, een beheersysteem voor inhoud, of in gewone bestanden. Als bezoeker zie je dat ontwerp nergens. Toch bepaalt het jarenlang hoe snel en foutloos je site te onderhouden is. Waarom dit extra telt bij een headless website, waar inhoud en vormgeving los van elkaar staan, legt wat is een headless CMS uit.

Van losse pagina's naar bouwstenen met velden

De meeste websites zijn opgebouwd als losse pagina's. Op elke pagina staat een tekstvak waar alles in gaat: de uitleg, het adres in de voettekst, de openingstijden op de contactpagina en nog eens in een blok op de homepage. Dat werkt, tot er iets verandert. Dan moet iemand onthouden waar die gegevens overal staan.

Met een content model draai je dat om. Een gegeven staat één keer in een vast veld, en de website haalt het op waar het nodig is. Een pagina wordt dan een samenstelling van bouwstenen, niet de plek waar de inhoud woont.

Losse pagina's Content model
Waar staat het adres? Op elke pagina waar het voorkomt Op één plek, in het veld 'adres'
Telefoonnummer verandert Alle pagina's nalopen Eén veld aanpassen
Nieuwe vacature plaatsen Pagina kopiëren en tekst overschrijven Nieuw item met vaste velden invullen
Overzicht van alle vacatures Met de hand bijhouden Bouwt zichzelf op uit de items
Kans op tegenstrijdige informatie Groot Klein

Het grootste voordeel: inhoud wordt één keer ingevoerd en overal gebruikt. Een teamlid staat op de teampagina, bij de behandeling die hij doet en onder een vacature als contactpersoon. Het is steeds hetzelfde item. Verandert zijn functie, dan klopt die op alle drie de plekken.

Praktijkvoorbeeld: twee locaties, één databestand

Een van mijn lopende projecten is een tandartspraktijk met twee locaties: twee verouderde websites werden daar één nieuwe site, online sinds eind oktober 2026. Wat er bij zo'n samenvoeging allemaal komt kijken, staat in twee websites samenvoegen. Hier gaat het om één keuze in dat project.

De adressen, telefoonnummers en openingstijden van beide locaties staan in één databestand. Overal op de site worden ze daaruit gehaald. Verandert er een openingstijd, dan pas ik die op één plek aan en klopt hij na het opnieuw bouwen, ongeveer een minuut later, op elke pagina.

Voor een praktijk met twee adressen is dat geen luxe. Patiënten bellen het nummer dat ze zien. Staat er op één pagina nog een oud nummer of een verkeerde openingstijd, dan krijgt de balie de verwarde telefoontjes. Zo'n keuze maak je aan het begin van een project. Achteraf alle pagina's ombouwen is veel meer werk.

Zo ziet zo'n inhoudstype eruit, met verzonnen gegevens:

locaties:
  - naam: "Locatie Noord"
    adres: "Voorbeeldstraat 1"
    postcode: "1234 AB"
    plaats: "Voorbeeldstad"
    telefoon: "012 345 67 89"
    openingstijden:
      maandag: "08:00 - 17:00"
      vrijdag: "08:00 - 12:30"
  - naam: "Locatie Zuid"
    adres: "Proefplein 12"
    postcode: "1234 CD"
    plaats: "Voorbeeldstad"
    telefoon: "012 345 98 76"

Voor het idee maakt het formaat van zo'n bestand niet uit. Wat de verschillen zijn tussen de gangbare formaten, lees je in Markdown, YAML en JSON.

Voorbeelden: team, vacatures, cases en veelgestelde vragen

Bijna elke bedrijfswebsite heeft inhoud die zich herhaalt. Dat zijn de eerste kandidaten voor een eigen inhoudstype.

Inhoudstype Velden Waar het terugkomt
Teamlid Naam, functie, foto, korte bio, locatie Teampagina, dienstpagina's, contactpersoon bij een vacature
Vacature Functie, uren, locatie, sluitingsdatum, omschrijving, contactpersoon Werken-bij-pagina, homepage, locatiepagina
Case Branche, vraag, aanpak, resultaat, foto, dienst Casepagina, bijbehorende dienstpagina, homepage
Veelgestelde vraag Vraag, antwoord, onderwerp FAQ-pagina, onderaan de dienstpagina met hetzelfde onderwerp
Locatie Naam, adres, telefoon, openingstijden, route Contactpagina, footer, locatiepagina

Bij vacatures zie je goed wat velden opleveren. Een sluitingsdatum als vast veld betekent dat een verlopen vacature automatisch van de site kan verdwijnen. Een vrij tekstvak kan dat niet. Wat er verder op een goede vacaturepagina hoort, staat in werken-bij-pagina maken.

Hetzelfde geldt voor veelgestelde vragen. Krijgt elke vraag een onderwerp mee, dan toont de site onder elke dienst precies de vragen die erbij horen en op de FAQ-pagina alles bij elkaar. Elk antwoord wordt één keer geschreven.

Zo stel ik een content model op in vijf stappen

Een content model ontwerp je voordat er een regel code wordt geschreven. Het lijkt op invulwerk, maar elke stap bevat keuzes die later lastig terug te draaien zijn. Zo pak ik het aan.

  1. Inventariseren wat er is. Ik loop alle pagina's en het aangeleverde materiaal langs en noteer welke informatie op meer dan één plek voorkomt. Adressen, prijzen, namen van medewerkers en openingstijden zijn de vaste kandidaten.
  2. Inhoudstypen benoemen. Wat bij elkaar hoort, wordt één type: alles over een medewerker is een teamlid, alles over een vestiging een locatie. Elk type krijgt een naam in gewone taal, zodat jij en ik hetzelfde bedoelen.
  3. Velden per type bepalen. Per veld leg ik vast wat voor soort gegeven het is (tekst, datum, foto, keuze uit een lijst) en of het verplicht is. Hier zitten de keuzes met de langste gevolgen. Een plaatsnaam in een eigen veld kun je filteren, een plaatsnaam midden in een zin niet. En een foto krijgt meteen een veld voor de alt-tekst, de omschrijving die een schermlezer voorleest.
  4. Verbanden vastleggen. Een teamlid werkt op een locatie, een case hoort bij een dienst. Die verbanden heten relaties. Ze zorgen ervoor dat een locatiepagina zelf kan tonen welke teamleden daar werken.
  5. Testen met echte inhoud. Ik vul voor elk type drie echte voorbeelden in, met jouw teksten en gegevens. Dan blijkt snel welk veld ontbreekt, welk veld niemand gebruikt en waar de inhoud toch weer in één tekstvak wil.

Voordat het model vastligt, controleer ik deze punten:

  • Elk gegeven dat op meer plekken staat, heeft één bron.
  • Velden heten naar wat ze zijn ('openingstijden'), niet naar waar ze staan ('blok rechtsboven').
  • Verplichte velden zijn aangegeven.
  • Datums, telefoonnummers en prijzen hebben een vaste schrijfwijze.
  • Elk inhoudstype met een eigen pagina heeft velden voor de titel en beschrijving in Google.
  • Wijzigingen in het model lopen via één persoon. Bij een vaste beheerder ben ik dat.

Dat punt over titels en beschrijvingen wordt makkelijk vergeten. Je merkt het pas als je pagina's in Google allemaal dezelfde titel tonen. Waarom het op een headless site extra aandacht vraagt, lees je in het vorige deel: headless website en SEO.

Waarom AI beter werkt met gestructureerde inhoud

Voor het typwerk in de bestanden gebruik ik Claude Code, een codeer-agent; wat hij aanpast, bepaal en controleer ik. In website aanpassen met AI volg je zo'n wijziging van begin tot eind. Een goed content model maakt dat werk sneller en veiliger, om drie redenen.

Eén plek in plaats van twintig. Vraag je een AI om een telefoonnummer te wijzigen dat op twintig pagina's in lopende tekst staat, dan moet hij al die plekken vinden. Mist hij er één, of past hij per ongeluk een ander nummer aan, dan staat er foute informatie online. Staat het nummer in één veld, dan is de opdracht klein en de controle ook.

Velden zeggen wat iets is. Een AI die een vacature moet toevoegen, krijgt bij een content model een vast formulier om in te vullen: functie, uren, locatie, sluitingsdatum. Er hoeft niets bedacht te worden over opmaak of plek op de pagina. De kans dat er iets wordt vergeten of verzonnen, wordt kleiner, en ik zie in één oogopslag of alle velden kloppen.

Afspraken zijn te controleren. De agent werkt bij mij met vaste bouwafspraken per project. Daarin kan bijvoorbeeld staan dat contactgegevens altijd uit het databestand komen en nooit los in een pagina worden getypt. Houdt de agent zich daar niet aan, dan zie ik dat bij mijn controle. Welke regels er nog meer in zo'n afsprakenbestand passen, zie je in bouwafspraken voor je codeer-agent.

Ook software die je site van buitenaf leest, zoals zoekmachines, heeft baat bij gegevens die overal hetzelfde zijn. Een content model is bovendien een goede basis voor structured data: extra code waarmee je Google vertelt dat iets een adres of een openingstijd is.

Waarom een content model jaren meegaat

Een site met een slordig model ziet er op de eerste dag hetzelfde uit als een site met een goed model. Het verschil merk je bij de twintigste wijziging, of als er na drie jaar iets bij moet.

Een veld toevoegen is later een kleine klus. Een veld splitsen, hernoemen of een inhoudstype ombouwen raakt alle bestaande inhoud, de sjablonen die het tonen en soms de adressen van pagina's. Veranderen die adressen, dan zijn doorverwijzingen nodig om je plek in Google niet kwijt te raken. En staat het model in een CMS, dan zit het vast aan dat systeem. Elk CMS slaat inhoud op zijn eigen manier op, dus overstappen wordt een migratieproject.

Dit zijn de fouten die pas na een paar jaar tijd en geld kosten:

  • Te veel velden. Twintig velden voor een teamlid, waarvan er drie worden ingevuld. Elk veld moet een reden hebben: wordt het ergens getoond of gebruikt?
  • Te weinig structuur. Eén groot tekstvak per pagina, met daarin toch weer adressen en prijzen. Dan heb je de nadelen van losse pagina's plus extra administratie.
  • Velden genoemd naar de vormgeving. Een veld 'tekst blauw blok' verliest zijn betekenis zodra het blok groen wordt. Een veld hoort te heten naar de inhoud.
  • Alles vooraf willen vastleggen. Een content model groeit mee. Het werkt beter om te beginnen met de inhoudstypen die er nu zijn en later toe te voegen wat erbij komt.
  • Geen eigenaar. Mag iedereen velden toevoegen, dan heb je na een jaar drie velden voor hetzelfde gegeven.

Wie beheert het content model?

Zonder CMS ligt het model bij de beheerder, en voor wie ik een site bouw, ben ik dat. Jij hoeft dus geen velden te kennen. Je zegt wat er anders moet, en ik zet het in het juiste veld en controleer of het overal goed terechtkomt. Een nieuwe openingstijd is zo'n kleine wijziging die na mijn controle meteen online gaat. Komt er een nieuw soort inhoud bij, bijvoorbeeld vacatures op een site die die nog niet had, dan breid ik het model uit en bekijk jij eerst het resultaat op een voorbeeldadres, voordat het live gaat.

Ook een wijziging aan het model zelf komt in Git, waar elke eerdere versie bewaard blijft, met een korte uitleg erbij. Wie later meekijkt, of dat nu de freelancer is die bij nood voor mij invalt of een andere bouwer over een paar jaar, kan daardoor nalezen waarom de inhoud zo in elkaar zit.

Een beheerscherm zet ik er alleen bij als het iets toevoegt, bijvoorbeeld als je zelf nieuws of vacatures wilt plaatsen. Dan wordt het content model ook daar vastgelegd, als schema in het CMS. Welke systemen er zijn en wat ze kosten, vergelijk ik in het volgende deel: headless CMS vergelijken.

Conclusie: één keer invoeren, overal juist

Een content model is het ontwerp van je inhoud: welke soorten inhoud er zijn, uit welke velden ze bestaan en hoe ze samenhangen. Het effect is eenvoudig. Een gegeven staat op één plek en klopt overal, zoals de adressen en openingstijden van de twee locaties uit het praktijkvoorbeeld. De keuzes erachter zijn minder eenvoudig: welke velden, welke verbanden, welke namen. Die bepalen jarenlang hoe snel en foutloos je site te wijzigen is, ook met AI.

Voor jou betekent dat: je hoeft geen velden te ontwerpen en geen CMS te kiezen. Dat doe ik bij de bouw, met jouw inhoud als uitgangspunt, en daarna houd ik het model bij als vaste beheerder. Wil je weten welke beheersystemen er zijn voor teams die zelf invoeren, lees dan headless CMS vergelijken. Wil je zien hoe ik werk, download dan het pitchdeck.

Veelgestelde vragen

Wat is het verschil tussen een content model en een sitemap?

Een sitemap of paginastructuur laat zien welke pagina's je website heeft en hoe ze onder elkaar hangen, zoals een inhoudsopgave. Een content model beschrijft welke soorten inhoud er zijn en uit welke velden ze bestaan, zoals een vacature met een functie, uren, locatie en sluitingsdatum. De twee vullen elkaar aan. De paginastructuur bepaalt waar iets staat, het content model bepaalt wat het is. Eén vacature kan zo op de vacaturepagina, de homepage en een locatiepagina verschijnen, terwijl hij maar één keer is ingevoerd.

Wat is gestructureerde content?

Gestructureerde content is inhoud die is opgeslagen in vaste velden met een betekenis, in plaats van in één groot tekstvak. Een openingstijd staat dan in het veld 'openingstijden' en niet ergens halverwege een alinea. Daardoor kan een website die gegevens op elke plek hetzelfde tonen, sorteren en filteren. Ook software die je inhoud verwerkt, zoals een codeer-agent of een zoekmachine, kan er beter mee overweg. Een content model is het ontwerp dat bepaalt welke velden er zijn.

Kun je een content model later nog aanpassen?

Ja, maar niet elke aanpassing is even klein. Een veld toevoegen is meestal een kleine klus: nieuwe items krijgen het veld, oude worden aangevuld waar nodig. Een veld splitsen of hernoemen is lastiger, bijvoorbeeld één veld 'adres' opdelen in straat, postcode en plaats. Dan moet alle bestaande inhoud worden omgezet en moeten de sjablonen mee. Bij een site met inhoud in bestanden is dat goed te doen en terug te draaien via versiebeheer. Toch besteed ik bij de start de meeste aandacht aan de velden, omdat die keuzes jaren meegaan.

Heb je een CMS nodig voor een content model?

Nee. Een content model is een ontwerp van je inhoud, geen software. Je kunt het vastleggen in een beheersysteem, waar het schema bepaalt welke invulvelden je ziet. Het kan ook in gewone databestanden in de projectmap van je website. Voor mijn maatwerksites is dat het uitgangspunt: geen CMS, wel een vaste beheerder die het model bijhoudt. Een beheerscherm komt er alleen bij als het iets toevoegt, bijvoorbeeld als je zelf vacatures wilt plaatsen. Het gereedschap kies je pas als duidelijk is hoe je inhoud in elkaar zit.

Benieuwd hoe ik dit in de praktijk aanpak?

Het pitchdeck laat de hele werkwijze zien.

Geschreven door

Marketing freelancer uit 's-Hertogenbosch. Volg op LinkedIn (opent in een nieuw tabblad)