Directus vs Payload vs Supabase: Which Backend Fits Your Stack in 2026

Directus, Payload, and Supabase solve different problems. Directus is a database-first CMS for teams with an existing SQL database. Payload is a code-first CMS built into Next.js. Supabase is a Postgres backend you can shape into a CMS. Pick based on your content team's technical skill, your frontend framework, and whether you need a CMS or a general-purpose backend.

Key Takeaways

• Directus fits teams with an existing SQL database and non-technical editors who need a polished admin panel without writing code.
• Payload is the strongest fit for Next.js projects: it runs as a plugin with a zero-overhead Local API and full TypeScript types.
• Supabase is a Postgres backend, not a CMS. Use it when row-level security, realtime data, or Postgres extensions matter more than editorial workflows.
• All three are open source and self-hostable. This keeps lock-in risk low compared with proprietary SaaS CMS platforms.
• Pricing and free-tier limits differ a lot across vendors. Check each platform's current pricing page before you commit.

Updated 15 August 2026: sources added, experience claims checked against our project record, summary added.

The Core Identity of Each Tool

Before we get into specifics, you need to know what each tool actually is at its core. The overlap in feature sets can be misleading.

Directus is a database-first headless CMS. It wraps an existing SQL database (Postgres, MySQL, SQLite, MS SQL, MariaDB, CockroachDB) with an auto-generated API and a polished admin panel. You design your database. Directus reads it and gives you a UI. It's written in TypeScript and runs on Node.js.

Payload is a code-first headless CMS built on Next.js (as of Payload 3.0). You define collections and fields in TypeScript config files. Payload then generates the database schema, admin UI, API endpoints, and TypeScript types from that config. It uses MongoDB or Postgres as its database layer.

Supabase is an open-source Firebase alternative -- a backend-as-a-service built on top of Postgres. It's not really a CMS. It's a database platform with auth, storage, realtime subscriptions, and edge functions. But teams use it as a CMS backend all the time, which is why it keeps showing up in these comparisons.

This distinction matters more than anything else in this article. Directus and Payload are purpose-built content management systems. Supabase is a general-purpose backend that you can shape into a content management system with enough effort.

Architecture and Data Modeling Compared

Directus: Database-First

Directus doesn't own your schema. You can point it at an existing database, and it will generate an admin panel automatically. This is powerful when you work with legacy systems, or when your data model serves multiple apps beyond content management.

The relationship modeling in Directus is solid. M2M, M2O, O2M, and even translations are handled through the UI. But there's a catch: Directus reads the database instead of generating it from code. So your schema changes happen in two places: migrations and the Directus admin. This can get messy in team settings if you're not careful.

## Directus schema snapshot (simplified)
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 (the current version in 2026) runs inside Next.js as a plugin. Your collections are defined 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',
    },
  ],
}

This code-first approach means your schema lives in version control. You get full TypeScript types generated from your config. It's the best DX of the three for TypeScript-heavy teams. The downside? Non-developers can't change the data model without a code change.

Supabase: SQL-First

With Supabase, you write SQL. Raw Postgres. You define your tables, set up row-level security policies, then interact through the auto-generated REST API (PostgREST) or the 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);

You get maximum flexibility but zero content management UI out of the box. You'll either build a custom admin, use a third-party tool, or wire up something like Directus on top of the same Postgres instance (yes, people actually do this).

Content Editing Experience

This is where the CMS-vs-not-a-CMS gap hits hardest.

Feature	Directus	Payload	Supabase
Built-in Admin UI	✅ Polished, customizable	✅ Next.js-native, very good	❌ Table editor only
Rich Text Editor	✅ WYSIWYG + Markdown	✅ Lexical-based (excellent)	❌ None
Media Library	✅ Full-featured	✅ Full-featured	⚠️ Storage buckets (no library UI)
Content Preview	✅ Via custom modules	✅ Native live preview	❌ Build your own
Localization	✅ Built-in translation system	✅ Field-level localization	❌ Manual implementation
Content Versioning	✅ Revisions built-in	✅ Drafts + versions	❌ Build your own
Workflow / Publishing	✅ Flows system	✅ Draft/publish states	❌ Custom logic needed
Non-developer friendly	✅ Very	✅ Yes	❌ Not at all

If your project involves content editors, people who write blog posts, manage product catalogs, update landing pages, Supabase is the wrong tool. Full stop. You'd spend weeks building what Directus and Payload give you on day one.

Payload's editor experience has gotten much better since 3.0. The Lexical-based rich text editor is flexible, the live preview feature works well with Next.js frontends, and the admin panel feels native because it runs right inside your Next.js app.

Directus has the most mature admin panel of the three. It's been refined over years, and the custom display/interface system lets you build complex editorial workflows without touching frontend code. For content-heavy teams, this matters a lot.

Developer Experience and API Design

API Styles

Directus gives you REST and GraphQL out of the box, plus a JavaScript SDK. The REST API follows a steady pattern, and the GraphQL setup is generated from your schema. It works, but the GraphQL can feel limited for complex nested queries.

Payload generates REST and GraphQL APIs, plus you get full access to the Local API (direct database queries with no HTTP overhead). Since Payload 3.0 runs inside your Next.js app, you can call payload.find() directly in your Server Components. This is a big advantage for Next.js projects.

// Payload Local API in a 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-generated by PostgREST, and the JavaScript client library is genuinely great. The query builder feels natural:

const { data, error } = await supabase
  .from('articles')
  .select('*, author:authors(*)')
  .eq('published', true)
  .order('created_at', { ascending: false })
  .range(0, 9)

Supabase also has realtime subscriptions, which neither Directus nor Payload offer natively. If you need live data updates (chat, notifications, collaborative editing), Supabase wins by default.

Type Safety

Payload has the best TypeScript story. Types are generated from your collection configs, and everything is strongly typed end-to-end. Supabase has solid type generation through its CLI (supabase gen types typescript), which creates types from your database schema. Directus has a TypeScript SDK, but the type generation needs extra setup and isn't as tightly built in.

Authentication, Permissions, and Row-Level Security

This is where Supabase truly shines. Postgres Row-Level Security (RLS) is the most granular and most battle-tested permissions model of the three. You define policies at the database level, and they apply no matter how the data is accessed. It's very powerful for multi-tenant SaaS apps.

Directus has a role-based permissions system that works at the collection and field level. It's easy to use in the admin panel and enough for most CMS use cases. You can set per-role CRUD permissions and even add custom filter rules.

Payload offers field-level and collection-level access control through functions in your 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',
      },
    },
  ],
}

For a standard CMS with editors, reviewers, and admins, all three work fine. For complex multi-tenant apps with dynamic permission rules, Supabase's RLS is the most powerful choice.

Self-Hosting, Cloud, and Pricing in 2026

All three are open source and self-hostable. But the cloud pricing tells you a lot about their target markets.

Plan	Directus Cloud	Payload Cloud	Supabase Cloud
Free tier	❌ No free cloud	✅ 1 project, limited	✅ 2 projects, limited database size
Starter/Pro	$99/mo (Professional)	$35/mo (Standard)	$25/mo (Pro)
Team/Business	$399/mo (Enterprise)	Custom pricing	$599/mo (Team)
Self-hosted cost	Free (open source)	Free (open source)	Free (open source)
Database included	✅ Managed	✅ Managed Postgres	✅ Managed Postgres
CDN/Storage	Included	Included	Included with limits

Pricing current as of Q3 2026. Check each platform's pricing page for the latest rates.

Payload Cloud is the most affordable managed option for small-to-medium projects. Supabase's free tier is the most generous for prototypes and side projects. Directus Cloud targets larger teams willing to pay for a polished managed setup.

Self-hosting changes the math a lot. All three run well on a cheap VPS. Directus and Supabase have official Docker Compose setups that work reliably. Payload deploys anywhere Next.js runs: Vercel, Railway, Fly.io, or your own server.

For our headless CMS development projects, we usually recommend self-hosting on Railway or Fly.io for cost efficiency, with managed cloud only when the client needs guaranteed SLAs.

Performance and Scalability Benchmarks

Performance gaps between these three tools follow straight from their architecture. In production Next.js builds, Payload's Local API usually beats REST-based queries because it skips HTTP overhead. Your Server Components query the database directly during rendering. Supabase's raw Postgres access is usually the fastest option for bulk operations and full-text search, since you work with native Postgres search and pgvector instead of an extra layer. Directus adds an extra layer on top of your database, which usually costs some speed compared to the other two, though it stays fast enough for normal content-serving workloads.

Operation	Directus	Payload	Supabase
Simple list query	Moderate	Fastest (Local API)	Fast
Nested relationship query	Slower (extra abstraction layer)	Fastest (Local API)	Fast
Full-text search	Moderate	Fast	Fastest (native Postgres search)
Bulk insert	Moderate	Fast	Fastest
Cold start	Slower	Faster	Always running, no cold start

Payload's Local API is the fastest option for Next.js apps because there's no HTTP overhead. You query the database directly from your rendering process. Supabase's raw Postgres speed is hard to beat for data-heavy work. Directus adds some overhead through its extra layer, but it's fine for content-serving workloads.

For search, Supabase has an edge because you can use Postgres's native full-text search, trigram indexes, and even the pgvector extension for semantic search. Directus and Payload both support search but use their own tools instead of Postgres directly.

The Decision Framework: When to Use Which

Here's the real framework. Answer these questions, and your choice becomes clear.

Choose Directus When:

• Your content team is large and non-technical
• You need to wrap an existing database with a CMS layer
• You use a database other than Postgres (MySQL, MS SQL, etc.)
• You need a standalone CMS that serves multiple frontends (web, mobile, kiosk)
• Your frontend isn't Next.js (maybe Astro, Nuxt, or SvelteKit)
• You want the most freedom to customize the admin UI without code

Directus pairs well with Astro for content-heavy sites where build-time rendering and island architecture make more sense than a full React framework.

Choose Payload When:

• Your frontend is Next.js (this is the killer use case)
• Your team is TypeScript-first and wants type safety everywhere
• You want CMS and frontend in a single deployable unit
• You need live preview and visual editing tools
• You want code-defined schemas in version control
• You're building a site with a well-defined content model up front

Payload is our go-to pick for Next.js development projects where content management is a core need. The fit is unmatched.

Choose Supabase When:

• You're building an application, not a content website
• You need realtime features (chat, live updates, collaboration)
• You need complex multi-tenant permissions (RLS is king)
• Your main need is a backend, and content is secondary
• You want to use Postgres extensions (pgvector, PostGIS, pg_cron)
• Your team is fine building its own admin interfaces
• You're building a SaaS product where user-generated data matters more than editorial content

Real Project Scenarios

Scenario 1: Marketing Website with Blog

Best choice: Payload (if Next.js) or Directus (if Astro/other)

A marketing site with 50-200 pages, a blog, and a small content team of 2-3 people. You need landing page flexibility, image optimization, SEO metadata management, and maybe some A/B testing.

Payload's live preview feature is handy here. Content editors can see exactly what the page will look like before they publish. The block-based field type lets you build flexible landing pages without giving editors too much freedom.

Scenario 2: E-commerce Product Catalog

Best choice: Directus or Payload

A product catalog with 5,000+ SKUs, complex categories, multiple price lists, and integration with inventory systems. The key here is data modeling flexibility and handling structured data well.

Directus edges ahead if you need to connect to an existing product database without moving data. Payload wins if you build from scratch and want type-safe product queries in your Next.js storefront.

Scenario 3: Multi-Tenant SaaS Platform

Best choice: Supabase

A platform where each customer has its own data space, with role-based access, realtime notifications, and user-generated content. You need row-level security, edge functions for business logic, and the ability to scale horizontally.

This isn't a CMS project. It's an application backend project. Supabase was built for exactly this.

Scenario 4: Internal Knowledge Base

Best choice: Payload or Directus

An internal wiki/knowledge base for a 200-person company. Rich text content, categories, search, and role-based access. Content editors range from technical to non-technical.

Either CMS works well here. Directus has a slight edge for non-technical teams because the admin panel needs zero code to customize. Payload is better if you want a polished, branded frontend experience.

Migration Paths and Lock-In Considerations

Lock-in is real. Think about it before you commit.

Directus has the least lock-in because your database schema is independent of the CMS. Remove Directus, and you still have a clean, standard SQL database. Your data isn't stuck in a proprietary format.

Payload stores data in standard Postgres (or MongoDB) tables, but the schema follows Payload's conventions. Moving away means some rework, but your data still sits in a standard database.

Supabase is just Postgres. Zero lock-in. You can take your database dump and run it on any Postgres instance. The client library just wraps PostgREST and GoTrue. If Supabase vanished tomorrow, you'd need to replace some API calls, but your data and schema would stay intact.

All three score well on lock-in compared to proprietary CMS platforms like Contentful or Sanity. With those platforms, your data lives in someone else's cloud, and exporting it is never a full process.

FAQ

Can I use Supabase as a headless CMS?

Technically yes, but you'll build CMS features from scratch: content editing UI, media management, revision history, publishing workflows. For small projects with developer-only content management, it can work. For anything with non-technical editors, use a real CMS like Payload or Directus, and connect Supabase for app data if needed.

Is Payload really free? What's the catch?

Payload CMS is open source under the MIT license, and you can self-host it at no cost. Payload Cloud is the paid managed hosting option, starting at $35 a month for the Standard plan. The real catch is that some premium features, like the form builder and SEO plugins, work best in the hosted setup, though the core CMS still works fully without paying anything.

Can I use Directus and Supabase together?

Yes. Point Directus at a Supabase Postgres database to get Directus's admin panel for content management alongside Supabase's realtime subscriptions, auth, and edge functions for app features. The two tools work well together because they sit at different layers: one for content, one for app infrastructure.

Which is best for a Next.js project?

Payload is the strongest fit for Next.js projects. Since Payload 3.0, the CMS runs inside your Next.js app as a plugin. This gives you the Local API for zero-overhead database queries in Server Components, native live preview, and one single deployment. We used this pairing on the SleepDr.com rebuild, moving the site from WordPress to Next.js 15 and Payload CMS and raising its Lighthouse score from 35 to 94.

How do these compare to Strapi in 2026?

Strapi v5 is a solid option but has fallen behind in a few spots. Its admin panel feels dated next to Payload's, its TypeScript support isn't as strong, and its licensing model has grown more restrictive. Directus offers a similar database-wrapping approach with a more modern UI, and Payload gives TypeScript teams a better developer experience overall. Strapi's main edge is its larger plugin ecosystem and bigger community, but the gap is closing.

What about Sanity, Contentful, or other SaaS CMS platforms?

Sanity and Contentful are solid products, but they're proprietary SaaS platforms. Your data lives on their servers, pricing scales with usage, and you depend on their infrastructure. Directus, Payload, and Supabase are all open source and self-hostable instead, which gives you more control over cost and deployment. If data ownership and deployment freedom matter to you, the open-source options win. We cover this in more detail on our headless CMS development page.

Which has the best plugin/extension ecosystem?

Directus currently has the most CMS-specific plugins through its extension marketplace, covering custom interfaces, displays, and modules. Payload has a smaller but growing set of official plugins for SEO, forms, nested docs, and redirects. Supabase supports a large ecosystem of Postgres extensions instead, which serve a different purpose but add real power for database-level features.

What's the best option for a small team with limited budget?

Payload self-hosted on Vercel's free tier or Railway's hobby plan gives a small team a full CMS at no monthly cost for low-traffic projects, and Supabase's free tier works well for prototyping too. Directus needs self-hosting for free use since it has no free cloud tier, but it runs fine on a cheap VPS. If budget is tight, reach out to us and we can map out the most cost-effective setup for your project.

Key takeaway:

Pick the tool whose core identity matches your project: CMS vs backend platform.