Je deploy is klaar, de site is live, en drie weken later stuurt je content team je een bericht: de image uploads time out, geneste categorieën worden niet opgeslagen, en de API response klimt voorbij de 800ms. Ik heb dit scenario de afgelopen twee jaar met Directus, Payload, en Supabase in productieprojecten herbouwd — dezelfde symptomen, elke keer andere oorzaken. Het antwoord hangt af van dingen die de landing pages overslaan: hoe je editors workflows structureren, hoe je relationele graaf er echt uitziet, en of je dit stack nog gebruikt wanneer de Series A sluit. Hier is het framework dat bepaalt welke backend je volgende zes sprints overleeft.

Dit is geen feature checklist vergelijking. Het is het decision framework dat ik eigenlijk gebruik bij het scopen van projecten bij Social Animal, verfijnd door tientallen headless builds. Aan het eind weet je welk tool past in je specifieke situatie zonder jezelf in twijfel te trekken.

Inhoudsopgave

Directus vs Payload vs Supabase: Welke CMS Backend te gebruiken in 2026

De kernidentiteit van elk tool

Voordat we in specifieke details duiken, moet je begrijpen wat elk tool eigenlijk is op zijn kern, want de overlap in featuresets kan misleidend zijn.

Directus is een database-first headless CMS. Het wikkelt een bestaande SQL database (Postgres, MySQL, SQLite, MS SQL, MariaDB, CockroachDB) in met een auto-gegenereerde API en een gepolijst admin panel. Je ontwerpt je database, Directus inspecteert het en geeft je een UI. Het is geschreven in TypeScript en draait op Node.js.

Payload is een code-first headless CMS gebouwd op Next.js (sinds Payload 3.0). Je definieert collections en fields in TypeScript config files, en Payload genereert de database schema, admin UI, API endpoints, en TypeScript types van die config. Het gebruikt MongoDB of Postgres als database layer.

Supabase is een open-source Firebase alternatief -- een backend-as-a-service gebouwd op Postgres. Het is eigenlijk helemaal geen CMS. Het is een database platform met auth, storage, realtime subscriptions, en edge functions. Maar teams gebruiken het constant als CMS backend, daarom duikt het steeds op in deze vergelijkingen.

Deze onderscheiding is belangrijker dan wat dan ook in dit artikel. Directus en Payload zijn speciaal gebouwde content management systemen. Supabase is een generiek backend dat je kunt vormgeven in een content management systeem met genoeg inspanning.

Architectuur en datamodellering vergeleken

Directus: Database-First

Directus bezit je schema niet. Je kunt het naar een bestaande database wijzen en het zal automatisch een admin panel genereren. Dit is echt krachtig als je met legacy systemen werkt of wanneer je data model meerdere toepassingen buiten content management dient.

De relationship modeling in Directus is solide. M2M, M2O, O2M, en zelfs translations worden via de UI afgehandeld. Maar er is een voorbehoud: omdat Directus de database introspect in plaats van deze te genereren uit code, gebeuren je schema changes op twee plekken -- migrations en het Directus admin. Dit kan in teamomgevingen rommelig worden als je niet disciplinair bent.

# Directus schema snapshot (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: Code-First

Payload 3.0 (de huidige versie in 2026) draait in Next.js als plugin. Je collections zijn 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 code-first aanpak betekent dat je schema in version control leeft. Je krijgt volledig gegenereerde TypeScript types van je config. Het is de beste DX van alle drie voor TypeScript-heavy teams. Het nadeel? Non-developers kunnen het data model niet aanpassen zonder een code change.

Supabase: SQL-First

Met Supabase schrijf je SQL. Rauwe Postgres. Je definieert je tables, stelt row-level security policies in, en interacteert dan via de auto-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 nul content management UI out of the box. Je zult ofwel een custom admin bouwen, een third-party tool gebruiken, of iets zoals Directus op dezelfde Postgres instance draaien (ja, mensen doen dit echt).

Content editing ervaring

Dit is waar het CMS-vs-not-a-CMS onderscheid het hardst aankomt.

Feature Directus Payload Supabase
Built-in Admin UI ✅ Gepolijst, aanpasbaar ✅ Next.js-native, zeer goed ❌ Tabel editor alleen
Rich Text Editor ✅ WYSIWYG + Markdown ✅ Lexical-based (uitstekend) ❌ Geen
Media Library ✅ Volledig uitgebreid ✅ Volledig uitgebreid ⚠️ Storage buckets (geen library UI)
Content Preview ✅ Via custom modules ✅ Native live preview ❌ Bouw je zelf
Localisatie ✅ Built-in translation system ✅ Field-level localisatie ❌ Handmatige implementatie
Content Versioning ✅ Revisions built-in ✅ Drafts + versions ❌ Bouw je zelf
Workflow / Publishing ✅ Flows system ✅ Draft/publish states ❌ Custom logica nodig
Non-developer friendly ✅ Zeer ✅ Ja ❌ Helemaal niet

Als je project content editors omvat -- mensen die blog posts schrijven, product catalogi beheren, landing pages updaten -- is Supabase het verkeerde tool. Punt. Je zou weken besteden aan het bouwen wat Directus en Payload je op dag één geven.

Payload's editor ervaring is sinds 3.0 opmerkelijk goed geworden. De Lexical-based rich text editor is flexibel, de live preview feature werkt prachtig met Next.js frontends, en het admin panel voelt native omdat het letterlijk in je Next.js app draait.

Directus heeft het meest gemaakte admin panel van alle drie. Het is verfijnd over jaren, en het custom display/interface systeem betekent dat je complex editorial workflows kunt bouwen zonder frontend code aan te raken. Voor content-heavy organisaties, dit is belangrijk.

Directus vs Payload vs Supabase: Welke CMS Backend te gebruiken in 2026 - architectuur

Developer experience en API design

API-stijlen

Directus geeft je REST en GraphQL out of the box, plus een JavaScript SDK. De REST API volgt een consistent pattern, en de GraphQL implementatie is auto-gegenereerd van je schema. Het werkt, maar de GraphQL kan beperkt voelen voor complexe nested queries.

Payload genereert REST en GraphQL APIs, plus je krijgt volledige toegang tot de Local API (direct database queries zonder HTTP overhead). Omdat Payload 3.0 in je Next.js app draait, kun je payload.find() direct aanroepen in je Server Components. 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 is auto-gegenereerd door PostgREST, en de JavaScript client library is echt 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 subscriptions, wat Directus en Payload native niet bieden. Als je live data updates nodig hebt (chat, notifications, collaborative editing), wint Supabase automatisch.

Type Safety

Payload heeft het beste TypeScript verhaal. Types worden gegenereerd van je collection configs, en alles is end-to-end sterk getypeerd. Supabase heeft solide type generation via hun CLI (supabase gen types typescript), wat types van je database schema creëert. Directus heeft een TypeScript SDK maar type generation vereist extra setup en is niet zo nauw geïntegreerd.

Authenticatie, permissions en row-level security

Dit is waar Supabase echt schittert. Postgres Row-Level Security (RLS) is het meest granulaire, meest battle-tested permissions model van alle drie. Je definieert policies op database level, en ze gelden ongeacht hoe de data wordt benaderd. Het is ongelooflijk krachtig voor multi-tenant SaaS applicaties.

Directus heeft een role-based permissions system dat werkt op collection en field level. Het is intuïtief in het admin panel en volstaat voor meeste CMS use cases. Je kunt per-role CRUD permissions instellen en zelfs custom filter rules toevoegen.

Payload biedt field-level en collection-level access control via functies in je config:

{
  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 editors, reviewers, en admins, werken alle drie prima. Voor complexe multi-tenant applicaties met dynamische permission regels, is Supabase's RLS het meest krachtig.

Self-hosting, cloud en prijsstelling in 2026

Alle drie zijn open source en self-hostable. Maar de cloud pricing vertelt je veel over hun target markets.

Plan Directus Cloud Payload Cloud Supabase Cloud
Free tier ❌ Geen gratis cloud ✅ 1 project, beperkt ✅ 2 projects, 500MB DB
Starter/Pro €99/mo (Professional) €35/mo (Standard) €25/mo (Pro)
Team/Business €399/mo (Enterprise) Custom pricing €599/mo (Team)
Self-hosted cost Gratis (open source) Gratis (open source) Gratis (open source)
Database included ✅ Managed ✅ Managed Postgres ✅ Managed Postgres
CDN/Storage Inbegrepen Inbegrepen Inbegrepen met beperkingen

Prijzen per Q1 2026. Controleer elke platform's pricing pagina voor huidige kosten.

Payload Cloud is de meest betaalbare managed optie voor kleine-tot-middelgrote projecten. Supabase's free tier is het meest genereus voor prototyping en side projects. Directus Cloud richt zich op grotere organisaties die willen betalen voor een gepolijste managed ervaring.

Self-hosting verandert de vergelijking drastisch. Alle drie draaien prima op een €5-20/month VPS. Directus en Supabase hebben officiële Docker Compose setups die betrouwbaar werken. Payload deployt overal waar Next.js draait -- Vercel, Railway, Fly.io, je eigen server.

Voor onze headless CMS development projecten raden we doorgaans self-hosting aan op Railway of Fly.io voor kosteneffectiviteit, met managed cloud alleen wanneer de klant gegarandeerde SLAs nodig heeft.

Performance en scalability benchmarks

Ik heb enkele informele benchmarks gedraaid op gelijkwaardige hardware (4 vCPU, 8GB RAM, Postgres 16) met een dataset van ~50.000 content records.

Operatie Directus Payload Supabase
Eenvoudige list query (20 items) ~45ms ~12ms (Local API) / ~38ms (REST) ~18ms
Nested relationship query (depth 3) ~120ms ~35ms (Local API) / ~95ms (REST) ~55ms
Full-text search (1000 resultaten) ~180ms ~85ms ~40ms (pg_trgm)
Bulk insert (1000 records) ~2.1s ~1.8s ~0.9s
Cold start time ~3.5s ~2.8s N/A (altijd actief)

Payload's Local API is de snelste optie voor Next.js applicaties omdat er geen HTTP overhead is -- je zoekt direct de database vanuit je rendering process. Supabase's rauwe Postgres performance is moeilijk te verslaan voor data-heavy operaties. Directus voegt wat overhead toe via zijn abstractie layer, maar het is perfect prima voor content-serving workloads.

Voor search specifiek, heeft Supabase een significant voordeel omdat je Postgres's native full-text search, trigram indexes, en zelfs pgvector extension voor semantic search kunt gebruiken. Directus en Payload ondersteunen beide search maar vertrouwen op hun eigen implementaties in plaats van Postgres direct te benutten.

Het decision framework: wanneer welk tool gebruiken

Hier is het echte framework. Beantwoord deze vragen, en je keuze wordt duidelijk.

Kies Directus wanneer:

  • Je content team is groot en non-technisch
  • Je moet een bestaande database met een CMS layer omwikkelen
  • Je een database gebruikt anders dan Postgres (MySQL, MS SQL, enz.)
  • Je een standalone CMS nodig hebt die meerdere frontends dient (web, mobile, kiosk)
  • Je frontend is niet Next.js (misschien Astro, Nuxt, of SvelteKit)
  • Je wilt maximale flexibiliteit in admin UI aanpassing zonder code

Directus werkt prachtig samen met Astro voor content-heavy sites waar build-time rendering 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 wilt type safety overal
  • Je CMS en frontend in één deployable unit wilt
  • Je live preview en visual editing capabilities nodig hebt
  • Je code-defined schemas in version control wilt
  • Je een site bouwt waar het content model vooraf goed gedefinieerd is

Payload is onze go-to aanbeveling voor Next.js development projecten waarbij content management een kernvereiste is. De integratie is ongeëvenaard.

Kies Supabase wanneer:

  • Je bouwt een applicatie, geen content website
  • Je realtime features nodig hebt (chat, live updates, collaborative editing)
  • Je complexe multi-tenant permissions nodig hebt (RLS is superieur)
  • Je primaire behoefte is een backend, en content is secundair
  • Je Postgres extensions wilt gebruiken (pgvector, PostGIS, pg_cron)
  • Je team is comfortabel hun eigen admin interfaces te bouwen
  • Je een SaaS product bouwt waar user-generated data belangrijker is dan editorial content

Real project scenarios

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 content team van 2-3 mensen. Je hebt landing page flexibiliteit, image optimalisatie, SEO metadata management, en misschien wat A/B testing nodig.

Payload's live preview feature is perfect hier. Content editors kunnen precies zien hoe de pagina eruitziet voor publishing. Het block-based field type laat je flexibele landing pages bouwen zonder editors genoeg touw te geven om zichzelf op te hangen.

Scenario 2: E-commerce product catalog

Beste keuze: Directus of Payload

Een product catalog met 5.000+ SKUs, complexe categorisatie, meerdere price lists, en integratie met inventory systemen. Het sleutelding hier is data modeling flexibiliteit en het vermogen om structured data efficiënt af te handelen.

Directus heeft een voordeel als je je aan een bestaande product database moet verbinden zonder data te migreren. Payload wint als je van nul aan bouwt en type-safe product queries in je Next.js storefront wilt.

Scenario 3: Multi-tenant SaaS platform

Beste keuze: Supabase

Een platform waar elke klant zijn eigen data space heeft, met role-based access, realtime notifications, en user-generated content. Je hebt row-level security, edge functions voor business logic, en het vermogen om horizontaal te schalen.

Dit is geen CMS project -- het is een application backend project. Supabase is precies voor dit gebouwd.

Scenario 4: Interne knowledge base

Beste keuze: Payload of Directus

Een interne wiki/knowledge base voor een bedrijf met 200 personen. Rich text content, categorisatie, search, en role-based access. Content editors variëren van technisch tot non-technisch.

Elke CMS werkt prima hier. Directus heeft een licht voordeel voor non-technische teams omdat het admin panel nul code aanpassing vereist. Payload is beter als je een gepolijste, branded frontend ervaring wilt.

Migration paths en lock-in overwegingen

Lock-in is echt. Denk er voordat je commit.

Directus heeft de minste lock-in omdat je database schema onafhankelijk van de CMS is. Verwijder Directus, en je hebt nog steeds een schone, standaard SQL database. Je data is niet opgesloten in een propriëtair formaat.

Payload slaat data op in standaard Postgres (of MongoDB) tables, maar het schema volgt Payload's conventies. Migreren weg betekent wat dingen herstructureren, maar je data zit nog in een standaard database.

Supabase is gewoon Postgres. Nul lock-in. Je kunt je database dump nemen en het op elke Postgres instance draaien. De client library is gewoon een wrapper rond PostgREST en GoTrue. Als Supabase morgen verdween, zou je sommige API calls moeten vervangen maar je data en schema zouden volmaakt intact zijn.

Alle drie scoren goed op lock-in vergeleken met propriëtaire CMS platforms als Contentful of Sanity, waar je data in iemand anders cloud leeft en het exporteren is altijd een partieel process.

FAQ

Kan ik Supabase als headless CMS gebruiken?

Technisch ja, maar je bouwt CMS features van nul af -- content editing UI, media management, revision history, publishing workflows. Voor kleine projecten met developer-only content management kan het werken. Voor wat dan ook wat non-technische editors omvat, gebruik een echte CMS als Payload of Directus en verbind Supabase voor application data als nodig.

Is Payload echt gratis? Wat is het voorbehoud?

Payload CMS is echt open source onder de MIT licentie. Je kunt het gratis zelf hosten voor eeuwig. Payload Cloud is hun betaalde managed hosting service, startend bij €35/month. Het voorbehoud, als je het zo wilt noemen, is dat Payload Cloud wat premium features heeft als form builder en SEO plugins die gratis zijn maar voordeel hebben uit de hosted omgeving. De core CMS is volledig functioneel zonder iets te betalen.

Kan ik Directus en Supabase samen gebruiken?

Absoluut, en dit is een pattern dat ik meerdere keren heb gebruikt. Wijs Directus naar een Supabase Postgres database. Je krijgt Directus's admin panel voor content management en Supabase's realtime subscriptions, auth, en edge functions voor application features. De twee tools vullen elkaar goed aan omdat ze op verschillende layers opereren.

Welke is het beste voor een Next.js project?

Payload, en het is niet dichtbij. Sinds Payload 3.0 draait de CMS in je Next.js applicatie als plugin. Je krijgt de Local API voor zero-overhead database queries in Server Components, native live preview, en een enkele deployment. We gebruiken deze combinatie constant.

Hoe vergelijken deze met Strapi in 2026?

Strapi v5 is een solide optie maar blijft in wat opzichten achter. Zijn admin panel voelt verouderd vergeleken met Payload's, zijn TypeScript ondersteuning is niet zo sterk, en zijn licensing model is restrictiever geworden. Directus biedt een soortgelijke database-wrapping aanpak met een modernerui. Payload biedt beter DX voor TypeScript teams. Strapi's voornaamste voordeel is zijn grotere plugin ecosysteem en grotere community, maar het gat sluit.

Hoe zit het met Sanity, Contentful, of andere SaaS CMS platforms?

Sanity en Contentful zijn prima producten maar ze zijn propriëtaire SaaS platforms. Je data leeft op hun servers, prijsstelling schaalt met gebruik (en kan snel duur worden), en je bent afhankelijk van hun infrastructuur. Directus, Payload, en Supabase zijn alle open source en self-hostable. Als data ownership, cost control, en deployment flexibiliteit belangrijk zijn, winnen de open-source opties. We behandelen dit in meer detail op onze headless CMS development pagina.

Welke heeft het beste plugin/extension ecosysteem?

Directus heeft een marketplace met community extensions voor custom interfaces, displays, en modules. Payload heeft een groeiend plugin ecosysteem met officiële plugins voor SEO, forms, nested docs, en redirects. Supabase heeft Postgres extensions (honderden ervan) wat een ander doel dient maar ongelooflijk krachtig is. Voor CMS-specifieke plugins heeft Directus momenteel de meeste opties.

Welke is het beste voor een klein team met beperkt budget?

Payload zelf gehost op Vercel's gratis tier of Railway's hobby plan. Je krijgt een volledig CMS met nul maandelijkse kosten voor low-traffic projecten. Supabase's gratis tier is ook uitstekend voor prototyping. Directus vereist self-hosting voor gratis gebruik (geen gratis cloud tier), maar draait prima op een €5/month VPS. Als budget krap is en je hulp nodig hebt de meest kosteneffectieve architectuur te kiezen, neem contact met ons op -- we hebben veel teams geholpen de meest kosteneffectieve architectuur te vinden.