Directus vs Payload vs Supabase: Welke CMS Backend in 2026?
Directus, Payload of Supabase kiezen? Zo maak ik die beslissing in 2026
Ik heb in de afgelopen twee jaar productieprojecten opgeleverd met al drie deze tools. Elke keer als ik een nieuw project start, komt dezelfde vraag naar voren in onze architectuurdiscussies: Directus, Payload of Supabase? Het antwoord is nooit twee keer hetzelfde, omdat het afhangt van zaken die op marketingpagina's niet staan -- hoe je contentteam daadwerkelijk werkt, hoe je datarelaties eruit zien, en waar je over 18 maanden bent.
Dit is geen vergelijking van functielijsten. Het is het besluitvormingskader dat ik werkelijk gebruik bij het bepalen van de scope van projecten bij Social Animal, verfijnd door tientallen headless-builds. Aan het einde weet je welk tool bij jouw specifieke situatie past zonder aan jezelf te twijfelen.
Inhoudsopgave
- De kernidentiteit van elk tool
- Architectuur en datamodellering vergeleken
- Contentbewerkingservaring
- Ontwikkelaarservaring en API-ontwerp
- Authenticatie, machtigingen en Row-Level Security
- Zelf hosten, cloud en prijzen in 2026
- Prestatie- en schaalbaardheidsbenchmarks
- Het besluitvormingskader: Wanneer elk tool gebruiken
- Echte projectscenario's
- Migratietrajecten en lock-in-overwegingen
- Veelgestelde vragen
De kernidentiteit van elk tool
Voordat we in de details duiken, moet je begrijpen wat elk tool werkelijk is op zijn kern, want de overlap in functieset kan misleidend zijn.
Directus is een databasegeoriënteerd headless CMS. Het verpakt een bestaande SQL-database (Postgres, MySQL, SQLite, MS SQL, MariaDB, CockroachDB) met een automatisch gegenereerde API en een gepolijst beheerderspaneel. Je ontwerpt je database, Directus introspecteerd deze en geeft je een UI. Het is geschreven in TypeScript en draait op Node.js.
Payload is een codegeoriënteerd headless CMS gebouwd op Next.js (vanaf Payload 3.0). Je definieert collections en velden in TypeScript-configuratiebestanden, en Payload genereert het databaseschema, admin UI, API-eindpunten en TypeScript-typen op basis van die configuratie. Het gebruikt MongoDB of Postgres als databaselaag.
Supabase is een open-source Firebase-alternatief -- een backend-as-a-service gebouwd op Postgres. Het is eigenlijk helemaal geen CMS. Het is een databaseplatform met auth, opslag, realtime-abonnementen en edge functions. Maar teams gebruiken het constant als CMS-backend, daarom blijft het in deze vergelijkingen opduiken.
Dit onderscheid is belangrijker dan alles anders in dit artikel. Directus en Payload zijn doeleinde contentmanagementsystemen. Supabase is een general-purpose backend die je vormgeven kunt in een contentmanagementsystem met voldoende inspanning.
Architectuur en datamodellering vergeleken
Directus: Databasegeoriënteerd
Directus bezit je schema niet. Je kunt het wijzen naar een bestaande database en het genereert automatisch een beheerderspaneel. Dit is werkelijk krachtig als je met verouderde systemen werkt of als je datamodel meer dan contentbeheer serveert.
De relationshipmodellering in Directus is solide. M2M, M2O, O2M en zelfs vertalingen worden via de UI afgehandeld. Maar er is een addertje onder het gras: omdat Directus de database introspecteerd in plaats van deze vanuit code te genereren, gebeuren je schemawijzigingen op twee plekken -- migraties en het Directus-beheerderspaneel. Dit kan rommelig worden in teamomgevingen als je niet gedisciplineerd bent.
# Directus-schemamomentopname (vereenvoudigd)
collections:
- collection: articles
fields:
- field: title
type: string
interface: input
- field: content
type: text
interface: input-rich-text-md
- field: author
type: uuid
interface: select-dropdown-m2o
related_collection: authors
Payload: Codegeoriënteerd
Payload 3.0 (de huidige versie in 2026) draait in Next.js als plugin. Je collections worden gedefinieerd in TypeScript:
import { CollectionConfig } from 'payload'
export const Articles: CollectionConfig = {
slug: 'articles',
admin: {
useAsTitle: 'title',
},
fields: [
{
name: 'title',
type: 'text',
required: true,
},
{
name: 'content',
type: 'richText',
},
{
name: 'author',
type: 'relationship',
relationTo: 'authors',
},
],
}
Deze codegeoriënteerde benadering betekent dat je schema in versiebeheer leeft. Je krijgt volledige TypeScript-typen automatisch gegenereerd uit je configuratie. Het is de beste DX van de drie voor TypeScript-zware teams. Het nadeel? Niet-ontwikkelaars kunnen het datamodel niet wijzigen zonder een codewijziging.
Supabase: SQL-First
Met Supabase schrijf je SQL. Raw Postgres. Je definieert je tabellen, stelt row-level security policies in en interageert vervolgens via de automatisch gegenereerde REST API (PostgREST) of de JavaScript-client.
CREATE TABLE articles (
id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
title TEXT NOT NULL,
content JSONB,
author_id UUID REFERENCES authors(id),
created_at TIMESTAMPTZ DEFAULT now(),
published BOOLEAN DEFAULT false
);
-- Row Level Security
ALTER TABLE articles ENABLE ROW LEVEL SECURITY;
CREATE POLICY "Public can read published articles"
ON articles FOR SELECT
USING (published = true);
Je krijgt maximale flexibiliteit maar geen contentbeheer-UI uit het vak. Je bouwt ofwel een aangepast beheerderspaneel, je gebruikt een tool van derden, of je verbindt iets zoals Directus met dezelfde Postgres-instantie (ja, mensen doen dit werkelijk).
Contentbewerkingservaring
Dit is waar het CMS-vs-geen-CMS-onderscheid het hardst toeslag.
| Functie | Directus | Payload | Supabase |
|---|---|---|---|
| Ingebouwde beheerdersUI | ✅ Gepolijst, aanpasbaar | ✅ Next.js-native, erg goed | ❌ Alleen tabeleditor |
| Rich Text Editor | ✅ WYSIWYG + Markdown | ✅ Lexical-gebaseerd (uitstekend) | ❌ Geen |
| Mediabibliotheek | ✅ Volledig uitgebouwd | ✅ Volledig uitgebouwd | ⚠️ Opslagbuckets (geen bibliotheek-UI) |
| Contentvoorvertoning | ✅ Via aangepaste modules | ✅ Ingebouwde live preview | ❌ Bouw je eigen |
| Lokalisatie | ✅ Ingebouwd vertaalsysteem | ✅ Veldniveaulocalisatie | ❌ Handmatige implementatie |
| Contentversiebeheer | ✅ Revisies ingebouwd | ✅ Concepten + versies | ❌ Bouw je eigen |
| Werkstroom / Publiceren | ✅ Flows-systeem | ✅ Concept-/publicatietoestanden | ❌ Aangepaste logica nodig |
| Niet-ontwikkelaarvriendelijk | ✅ Erg | ✅ Ja | ❌ Helemaal niet |
Als je project contentredacteuren omvat -- mensen die blogposts schrijven, productcatalogussen beheren, landingspagina's bijwerken -- is Supabase het verkeerde tool. Punt uit. Je zou weken besteden aan het bouwen van wat Directus en Payload je op dag één geven.
Payload's editorervaring is sinds 3.0 opmerkelijk goed geworden. De Lexical-gebaseerde rich text editor is flexibel, de live preview-functie werkt prachtig met Next.js-frontends, en het beheerdersspaneel voelt native omdat het letterlijk in je Next.js-app draait.
Directus heeft het meest volwassen beheerdersspaneel van de drie. Het is jaren verfijnd, en het aangepaste display-/interfacesysteem betekent dat je complexe redactionele workflows kunt bouwen zonder frontendcode aan te raken. Voor contentintensieve organisaties is dit echt belangrijk.
Ontwikkelaarservaring en API-ontwerp
API-stijlen
Directus geeft je REST en GraphQL uit het vak, plus een JavaScript SDK. De REST API volgt een consistent patroon, en de GraphQL-implementatie wordt automatisch gegenereerd uit je schema. Het werkt, maar de GraphQL kan beperkt voelen voor complexe geneste queries.
Payload genereert REST- en GraphQL-API's, en je krijgt volledige toegang tot de Local API (rechtstreekse databasequeries zonder HTTP-overhead). Omdat Payload 3.0 in je Next.js-app draait, kun je payload.find() rechtstreeks in je Server Components aanroepen. Dit is een enorm voordeel voor Next.js-projecten.
// Payload Local API in een Next.js Server Component
import { getPayload } from 'payload'
import config from '@payload-config'
export default async function ArticlePage({ params }) {
const payload = await getPayload({ config })
const article = await payload.findByID({
collection: 'articles',
id: params.id,
depth: 2,
})
return <Article data={article} />
}
Supabase's API wordt automatisch gegenereerd door PostgREST, en de JavaScript-clientbibliotheek is werkelijk uitstekend. De query builder voelt natuurlijk:
const { data, error } = await supabase
.from('articles')
.select('*, author:authors(*)')
.eq('published', true)
.order('created_at', { ascending: false })
.range(0, 9)
Supabase heeft ook realtime-abonnementen, wat Directus en Payload standaard niet bieden. Als je live data-updates nodig hebt (chat, meldingen, gezamenlijke bewerking), wint Supabase standaard.
Typeveiligheid
Payload heeft het beste TypeScript-verhaal. Typen worden gegenereerd uit je collectionconfiguraties, en alles is end-to-end sterk getypeerd. Supabase heeft solide typegeneratie via hun CLI (supabase gen types typescript), die typen uit je databaseschema maakt. Directus heeft een TypeScript SDK, maar typegeneratie vereist aanvullende setup en is niet zo strak geïntegreerd.
Authenticatie, machtigingen en Row-Level Security
Dit is waar Supabase werkelijk glinster. Postgres Row-Level Security (RLS) is het meest granulaire, meest beproefd machtigingsmodel van de drie. Je definieert policies op databaseniveau, en ze gelden ongeacht hoe de data wordt benaderd. Het is ongelooflijk krachtig voor multi-tenant SaaS-applicaties.
Directus heeft een op rollen gebaseerd machtigingssysteem dat op collection- en veldniveau werkt. Het is intuïtief in het beheerdersspaneel en voldoende voor de meeste CMS-gebruiksgevallen. Je kunt per-rol CRUD-machtigingen instellen en zelfs aangepaste filterregels toevoegen.
Payload biedt veld- en collectionsniveautoegangscontrole via functies in je configuratie:
{
slug: 'articles',
access: {
read: () => true,
create: ({ req: { user } }) => user?.role === 'editor',
update: ({ req: { user } }) => user?.role === 'editor',
delete: ({ req: { user } }) => user?.role === 'admin',
},
fields: [
{
name: 'internalNotes',
type: 'textarea',
access: {
read: ({ req: { user } }) => user?.role === 'admin',
},
},
],
}
Voor een standaard CMS met redacteuren, reviewers en admins werken alle drie prima. Voor complexe multi-tenant applicaties met dynamische machtigingsregels is Supabase's RLS het meest krachtige optie.
Zelf hosten, cloud en prijzen in 2026
Alle drie zijn open source en zelf hostbaar. Maar de cloud-prijzen vertellen je veel over hun doelmarkten.
| Plan | Directus Cloud | Payload Cloud | Supabase Cloud |
|---|---|---|---|
| Gratis laag | ❌ Geen gratis cloud | ✅ 1 project, beperkt | ✅ 2 projecten, 500MB DB |
| Starter/Pro | $99/mo (Professional) | $35/mo (Standard) | $25/mo (Pro) |
| Team/Business | $399/mo (Enterprise) | Aangepaste prijzen | $599/mo (Team) |
| Zelf hosten kosten | Gratis (open source) | Gratis (open source) | Gratis (open source) |
| Database inbegrepen | ✅ Beheerd | ✅ Beheerde Postgres | ✅ Beheerde Postgres |
| CDN/Opslag | Inbegrepen | Inbegrepen | Inbegrepen met limieten |
Prijzen vanaf Q1 2026. Controleer de prijspagina van elk platform voor huidige tarieven.
Payload Cloud is de meest betaalbare beheerde optie voor kleine tot middelgrote projecten. Supabase's gratis laag is het meest genereus voor prototyping en side-projecten. Directus Cloud is gericht op grotere organisaties die willen betalen voor een gepolijste beheerde ervaring.
Zelf hosten verandert de vergelijking dramatisch. Alle drie draaien goed op een $5-20/maand VPS. Directus en Supabase hebben officiële Docker Compose-setups die betrouwbaar werken. Payload implementeert overal waar Next.js draait -- Vercel, Railway, Fly.io, je eigen server.
Voor onze headless CMS-ontwikkelingsprojecten bevelen we doorgaans zelf hosten op Railway of Fly.io aan voor kostenefficiëntie, met beheerde cloud alleen wanneer de klant gegarandeerde SLA's nodig heeft.
Prestatie- en schaalbaardheidsbenchmarks
Ik heb enkele informele benchmarks uitgevoerd op equivalente hardware (4 vCPU, 8GB RAM, Postgres 16) met een dataset van ~50.000 contentrecords.
| Operatie | Directus | Payload | Supabase |
|---|---|---|---|
| Eenvoudige lijstquery (20 items) | ~45ms | ~12ms (Local API) / ~38ms (REST) | ~18ms |
| Geneste relationship-query (depth 3) | ~120ms | ~35ms (Local API) / ~95ms (REST) | ~55ms |
| Volledig tekstzoeken (1000 resultaten) | ~180ms | ~85ms | ~40ms (pg_trgm) |
| Bulk invoegen (1000 records) | ~2.1s | ~1.8s | ~0.9s |
| Koude startijd | ~3.5s | ~2.8s | N/A (altijd actief) |
Payload's Local API is het snelste optie voor Next.js-applicaties omdat er geen HTTP-overhead is -- je bevraagt rechtstreeks de database vanuit je renderingsproces. Supabase's raw Postgres-prestaties zijn moeilijk te verslaan voor dataintensieve operaties. Directus voegt wat overhead toe via zijn abstractielaag, maar het is perfect prima voor content-serving workloads.
Voor zoeken in het bijzonder heeft Supabase een significant voordeel omdat je Postgres's native fulltext search, trigram-indexen en zelfs de pgvector-extensie kunt gebruiken voor semantisch zoeken. Directus en Payload ondersteunen beide zoeken, maar vertrouwen op hun eigen implementaties in plaats van rechtstreeks Postgres te benutten.
Het besluitvormingskader: Wanneer elk tool gebruiken
Hier is het werkelijke kader. Beantwoord deze vragen, en je keuze wordt duidelijk.
Kies Directus wanneer:
- Je contentteam is groot en niet-technisch
- Je moet een bestaande database met een CMS-laag omhullen
- Je gebruikt een andere database dan Postgres (MySQL, MS SQL, etc.)
- Je hebt een zelfstandig CMS nodig dat meerdere frontends serveert (web, mobile, kiosk)
- Je frontend is niet Next.js (misschien gebruik je Astro, Nuxt of SvelteKit)
- Je wilt maximale flexibiliteit in beheerders-UI-aanpassingen zonder code
Directus past prachtig samen met Astro voor content-zware sites waar render-time compilatie en island architecture meer zinvol zijn dan een volledig React-framework.
Kies Payload wanneer:
- Je frontend is Next.js (dit is het killer use case)
- Je team is TypeScript-first en wil typeveiligheid overal
- Je wilt CMS en frontend in een enkele inzetbare eenheid
- Je hebt live preview en visuele bewerkingsmogelijkheden nodig
- Je wilt codegedefinieerde schemas in versiebeheer
- Je bouwt een site waar het contentmodel van tevoren goed is gedefinieerd
Payload is onze standaardaanbeveling voor Next.js-ontwikkelingsprojecten waar contentbeheer een kernvereiste is. De integratie is ongeëvenaard.
Kies Supabase wanneer:
- Je bouwt een applicatie, geen contentwebsite
- Je hebt realtime-functies nodig (chat, live-updates, samenwerking)
- Je hebt complexe multi-tenant machtigingen nodig (RLS is koning)
- Je primaire behoefte is een backend, en content is secundair
- Je wilt Postgres-extensies gebruiken (pgvector, PostGIS, pg_cron)
- Je team voelt zich gemakkelijk bij het bouwen van hun eigen beheerderinterfaces
- Je bouwt een SaaS-product waarbij door gebruikers gegenereerde data belangrijker is dan redactionele content
Echte projectscenario's
Scenario 1: Marketing Website met Blog
Beste keuze: Payload (als Next.js) of Directus (als Astro/ander)
Een marketing site met 50-200 pagina's, een blog en een klein contentteam van 2-3 personen. Je hebt landingpage-flexibiliteit, afbeeldingsoptimalisatie, SEO-metagegevensbeheer en misschien wat A/B-testen nodig.
Payload's live preview-functie is hier perfect. Contentredacteuren kunnen precies zien hoe de pagina eruit zal zien voordat deze wordt gepubliceerd. Het blockgebaseerde veldtype laat je flexibele landingspagina's bouwen zonder redacteuren genoeg touw te geven om zichzelf mee op te hangen.
Scenario 2: E-commerce Productcatalogus
Beste keuze: Directus of Payload
Een productcatalogus met 5.000+ SKU's, complexe categorisering, meerdere prijslijsten en integratie met voorraaadsystemen. Het sleutelstuk hier is datamodelleringsflexibiliteit en het vermogen om gestructureerde data efficiënt af te handelen.
Directus wint voorkeur als je verbinding moet maken met een bestaande productdatabase zonder gegevens te migreren. Payload wint als je van nul af begint en type-veilige productqueries in je Next.js-storefront wilt.
Scenario 3: Multi-Tenant SaaS-Platform
Beste keuze: Supabase
Een platform waar elke klant hun eigen dataspatie heeft, met op rollen gebaseerde toegang, realtime-meldingen en door gebruikers gegenereerde content. Je hebt row-level security nodig, edge functions voor bedrijfslogica en het vermogen om horizontaal te schalen.
Dit is geen CMS-project -- het is een applicationbackend-project. Supabase is exact hiervoor gebouwd.
Scenario 4: Interne Kennisbank
Beste keuze: Payload of Directus
Een interne wiki/kennisbank voor een bedrijf van 200 personen. Rich text content, categorisering, zoeken en op rollen gebaseerde toegang. Contentredacteuren variëren van technisch tot niet-technisch.
Elk CMS werkt hier goed. Directus heeft een klein voordeel voor niet-technische teams omdat het beheerdersspaneel nul code vereist om aan te passen. Payload is beter als je een gepolijste, branded frontendervaring wilt.
Migratietrajecten en lock-in-overwegingen
Lock-in is echt. Denk erover na voordat je je committeert.
Directus heeft het minste lock-in omdat je databaseschema onafhankelijk van het CMS is. Verwijder Directus, en je hebt nog steeds een schone, standaard SQL-database. Je data is niet in een propriëtair formaat opgesloten.
Payload slaat data op in standaard Postgres (of MongoDB) tabellen, maar het schema volgt Payload's conventies. Migratie betekent enkele dingen herstructureren, maar je data zit nog steeds in een standaarddatabase.
Supabase is gewoon Postgres. Nul lock-in. Je kunt je databasedump nemen en deze op elk Postgres-exemplaar uitvoeren. De clientbibliotheek is slechts een wrapper rond PostgREST en GoTrue. Als Supabase morgen verdween, zou je sommige API-aanroepen moeten vervangen, maar je data en schema zouden volkomen intact zijn.
Alle drie scoren goed op lock-in vergeleken met propriëtaire CMS-platforms zoals Contentful of Sanity, waar je data in iemand anders cloud leeft en exporteren ervan altijd een gedeeltelijk proces is.
Veelgestelde vragen
Kan ik Supabase als headless CMS gebruiken? Technisch gezien ja, maar je bouwt CMS-functies van nul af -- contentbewerkings-UI, mediabeheer, revisiehistorie, publicatieworkflows. Voor kleine projecten met alleen-ontwikkelaar contentbeheer kan het werken. Voor alles wat niet-technische redacteuren betreft, gebruik een echt CMS zoals Payload of Directus en verbind Supabase voor applicationdata als nodig.
Is Payload werkelijk gratis? Wat is het addertje? Payload CMS is werkelijk open source onder de MIT-licentie. Je kunt het voor altijd zelf hosten zonder iets te betalen. Payload Cloud is hun betaalde beheerde hostingservice, vanaf $35/maand. Het addertje, als je het zo wilt noemen, is dat Payload Cloud enkele premium-functies heeft zoals formulierbuilder en SEO-plugins die gratis zijn maar profiteren van de gehoste omgeving. Het core CMS is volledig functioneel zonder iets te betalen.
Kan ik Directus en Supabase samen gebruiken? Absoluut, en dit is een patroon dat ik meerdere keren heb gebruikt. Wijs Directus naar een Supabase Postgres-database. Je krijgt Directus's beheerdersspaneel voor contentbeheer en Supabase's realtime-abonnementen, auth en edge functions voor applicationfuncties. De twee tools vullen elkaar goed aan omdat ze op verschillende lagen werken.
Welke is het beste voor een Next.js-project? Payload, en het is dicht. Sinds Payload 3.0 draait het CMS in je Next.js-applicatie als plugin. Je krijgt de Local API voor overhead-loze databasequeries in Server Components, ingebouwde live preview en een enkele implementatie. We gebruiken deze combinatie constant in ons Next.js-ontwikkelingswerk.
Hoe vergelijken deze met Strapi in 2026? Strapi v5 is een solide optie, maar is achtergebleven in een paar gebieden. Zijn beheerdersspaneel voelt verouderd vergeleken met Payload's, zijn TypeScript-ondersteuning is niet zo sterk en zijn licentiemodel is restrictiever geworden. Directus biedt een vergelijkbare database-omhullende benadering met een modernere UI. Payload biedt betere DX voor TypeScript-teams. Strapi's belangrijkste voordeel is zijn grotere plugin-ecosysteem en grotere gemeenschap, maar de kloof sluit.
Wat met Sanity, Contentful of andere SaaS CMS-platforms? Sanity en Contentful zijn goede producten, maar het zijn propriëtaire SaaS-platforms. Je data leeft op hun servers, prijzen schalen met gebruik (en kunnen snel duur worden), en je bent afhankelijk van hun infrastructuur. Directus, Payload en Supabase zijn allemaal open source en zelf hostbaar. Als data-eigenaarschap, kostenbeheersing en implementatieflexibiliteit voor je belangrijk zijn, winnen de open-source opties. We behandelen dit uitgebreider op onze headless CMS-ontwikkelingspagina.
Welke heeft het beste plugin-/extension-ecosysteem? Directus heeft een marketplace met community-extensies voor aangepaste interfaces, displays en modules. Payload heeft een groeiend plugin-ecosysteem met officiële plugins voor SEO, formulieren, geneste docs en redirects. Supabase heeft Postgres-extensies (honderden ervan) die een ander doel dienen, maar ongelooflijk krachtig zijn. Voor CMS-specifieke plugins heeft Directus momenteel de meeste opties.
Wat is de beste optie voor een klein team met beperkt budget? Payload zelf gehost op Vercel's gratis laag of Railway's hobby-plan. Je krijgt een volledig CMS met nul maandelijkse kosten voor laagverkeersprojecten. Supabase's gratis laag is ook uitstekend voor prototyping. Directus vereist zelf hosten voor gratis gebruik (geen gratis cloud laag), maar draait prima op een $5/maand VPS. Als budget krappe is en je hulp nodig hebt om de juiste keuze te maken, neem contact met ons op -- we hebben veel teams geholpen de meest kosteneffectieve architectuur te vinden.