Backend

Headless CMS is table stakes in 2026. Your marketing team needs to publish without touching code. Your frontend is Astro, Next.js, or SvelteKit. Your content lives in a database, served as JSON to whatever frontend you're building. Three platforms own the space: Sanity (hosted, real-time sync, free tier that doesn't choke), Strapi (self-hosted, Postgres-backed, dev-friendly, truly free forever), and Payload (TypeScript-first, rich admin UI, self-hosted, batteries included). Aidxn has shipped content workflows on all three for clients and internal projects. Sanity wins when you want managed hosting and real-time collab. Strapi dominates when budget is zero and you're comfortable deploying to your own infra. Payload is the dark horse — if you're building a custom admin UI and want TypeScript control, Payload is unbeatable. Here's the honest breakdown, the comparison table, three real case studies, and the decision tree for your next project.

What Is Headless CMS?

A headless CMS decouples content from presentation. Your marketing team edits content in an admin UI; the frontend fetches it as JSON. No HTML templates, no server-side rendering overhead, just data. Sanity, Strapi, and Payload all do this, but the implementation shape differs wildly. Sanity is cloud-hosted and syncs content to your frontend in real time (your page updates as the editor types). Strapi runs on your servers — you provision the VM, Strapi manages the Node.js/Postgres layer. Payload is similar to Strapi, but the admin UI is a React app you deploy with the API, giving you more control over customization. All three are REST + GraphQL capable. The decision is mostly about: hosting model (cloud vs self), pricing (free forever vs freemium), and who owns the deploy button.

The Three Platforms Compared

Sanity: The Hosted Real-Time Darling

Sanity is a cloud-hosted headless CMS built for teams. You define a content schema in JavaScript; Sanity generates an admin UI. Content syncs to your frontend via REST or GraphQL. The killer feature is real-time collab: multiple editors can work simultaneously, and subscribers on the frontend see changes instantly. Pricing: free tier is genuinely usable (unlimited projects, unlimited API calls, 1GB assets). Pro ($99/month) adds higher assets, member seats, and advanced workflows. At $99/month, Sanity is the most expensive entry for indie projects, but the break-even is quick if you have a team editing content. DX is excellent: schema is GROQ queries and Portable Text (richer than Markdown). Deployment is zero-friction — you deploy to Netlify/Vercel, Sanity handles the backend. The catch: you're locked into Sanity's cloud. Exporting content out is possible but painful. Data residency is limited to US/EU regions (no control). If GDPR/compliance is paranoid, self-hosting is not an option — that's Strapi or Payload's job.

Strapi: The Self-Hosted Free Forever

Strapi is a Node.js + SQLite/Postgres headless CMS you run on your own infrastructure. Deploy to a $5/month VPS, a Docker container, or Railway. Strapi is genuinely free forever: no watermarks, no feature limits, no hidden pricing. You pay for hosting (compute, database) not software. The admin UI is React; content is stored in your Postgres database. Schema is auto-generated from your Strapi config — you don't write GraphQL by hand. REST and GraphQL APIs are automatic. The DX is friendly: install via npm, define collections, and the API scaffold itself. Customization is built-in: middleware, webhooks, plugins, and role-based access. The downside: you own the deploy. Database backups, uptime monitoring, CDN setup — that's on you. Strapi is not real-time: when content changes, the frontend doesn't auto-sync (you need webhooks or polling). For teams without DevOps chops, self-hosting creates friction. But for developers and teams comfortable with infra, Strapi's total cost of ownership is lowest.

Payload: The TypeScript Control Freak's Dream

Payload is a TypeScript-first headless CMS that runs on your infra. Like Strapi, you deploy Payload + a Postgres database. Unlike Strapi, Payload's admin UI is a React application you own — you can customize every button, field type, and workflow. The schema is TypeScript (not config), which means full IDE autocomplete and type safety. Content is stored in Postgres; REST and GraphQL APIs are generated. Pricing is open-source free forever (no cloud offering). Community edition is unlimited; you only pay if you fork to modify (Payload recommends this for custom features). The DX is outstanding for JavaScript teams: it's `npm install payload`, define your schema in TypeScript, `npm run build`, and deploy. Customization is granular: you can hook into every step (beforeCreate, afterValidate, beforeDelete). The admin UI is React, so you can inject custom pages, fields, and workflows with React components. The catch: Payload is younger than Strapi (smaller ecosystem, fewer plugins). For simple content models, Payload might feel over-engineered. For complex, custom admin workflows, Payload is unbeatable.

Comparison Table

Feature	Sanity	Strapi	Payload
Hosting Model	Cloud-hosted (Sanity manages)	Self-hosted (you manage)	Self-hosted (you manage)
Pricing	Free (1GB assets), Pro $99/mo	Free forever (pay for hosting)	Free (open source), pay for custom
Real-Time Sync	Yes, built-in	No (webhooks, polling)	No (webhooks, polling)
Schema Definition	JavaScript objects (Portable Text)	Config files or UI	TypeScript (full type safety)
Admin UI Customization	Limited (plugins)	Moderate (plugins + hooks)	Full (React components)
API Coverage	REST + GraphQL + real-time	REST + GraphQL	REST + GraphQL
Data Ownership	Sanity Cloud (limited control)	100% yours (Postgres db)	100% yours (Postgres db)
Best For	Marketing teams, real-time content	Dev-led teams, zero budget	Custom workflows, TypeScript-first

Three Decision Branches

Branch 1: Marketing Team + Budget

Sanity. If your content is managed by non-technical editors and you have budget ($99/month is peanuts for a SaaS), Sanity's cloud hosting and real-time collab are worth the premium. Editors see changes instantly; publishing is seamless. Multi-team content versioning, scheduled content, and asset management are polished. Zero DevOps overhead. You deploy the frontend to Netlify/Vercel, Sanity owns the CMS API. For agencies and content-heavy SaaS, Sanity is the obvious choice.

Branch 2: Startup / Indie / Zero Budget

Strapi. If budget is zero and you're comfortable deploying to a VPS, Strapi is genuinely free forever. Deploy to Railway, Render, or a $5 DigitalOcean VPS. Total cost: $5–10/month for hosting, zero software fees. You own the data. Strapi's admin UI is intuitive enough for non-technical editors. For indie makers and bootstrapped teams, Strapi is the answer. The trade-off: you're on-call for infra (backups, upgrades, monitoring). Strapi is battle-tested at scale (100K+ projects deployed). The ecosystem is mature.

Branch 3: Bespoke Admin Workflows + Dev Control

Payload. If you need a custom admin UI (e.g., bulk editors, live previews, custom field types) and you want TypeScript type safety throughout, Payload is unbeatable. The admin UI is a React app you control. Define field types with TypeScript, add custom pages, hook into validation, and deploy with your API. For SaaS with complex content models or teams wanting full control, Payload is the right call. The learning curve is steeper (fewer tutorials than Strapi), but the payoff is a tight, custom system.

Three Aidxn Case Studies

Case Study 1: Rebuild Relief (Sanity)

Rebuild Relief's marketing site and blog uses Sanity. Editors are non-technical; they need to publish blog posts, case studies, and testimonials without code. Sanity's admin UI is intuitive, real-time collab lets multiple editors work on the same post, and the free tier covers unlimited content. Sanity's Portable Text (richer than Markdown) lets editors embed custom components in blog posts (case study cards, testimonial blocks). Content is served to the frontend (Astro) via GraphQL. When an editor publishes, the Netlify build trigger fires automatically (webhook). Cost is zero (free tier). Verdict: Sanity was the right choice because editorial workflow maturity and zero-friction publishing beat self-hosting complexity.

Case Study 2: Staff Operations Dashboard (Strapi)

Staff Operations Dashboard is Aidxn's internal location-scouting SaaS. Content is service listings, team info, and help docs. Budget was zero. We deployed Strapi to Railway (free tier), Postgres database to Railway, and the frontend to Netlify. Total cost: $0 (all free tiers). Strapi auto-generated REST APIs for services and team members. Webhooks trigger Netlify rebuilds when content changes. The admin UI isn't as polished as Sanity, but it's good enough for internal use. Verdict: Strapi was the right choice because the cost was zero and we had DevOps chops to manage infrastructure.

Case Study 3: Aidxn Design (Payload)

Aidxn Design's portfolio uses Payload for project metadata (case studies, testimonials, service details). The reason: we needed a custom admin UI that let designers preview projects before publishing, bulk-edit metadata, and manage tags without touching React code. Payload's admin is React, so we added a custom "Live Preview" page that renders the project card in real time as metadata is edited. Schema is TypeScript, providing autocomplete for fetching project data in Astro. Hosted on Railway + Postgres. Total cost: ~$12/month (Railway Postgres). Verdict: Payload was the right choice because custom admin workflows and TypeScript type safety justified the self-hosting burden.

Migration Considerations

Moving from one CMS to another is painful. Content is easier than schema mapping. If you start with Sanity and need to self-host, exporting via REST API is straightforward (fetch all documents, transform to JSON). Importing to Strapi or Payload requires schema definition on the destination and a migration script. All three CMSes support bulk import via API. The real cost is downtime and testing — you need to validate that all content rendered correctly on the new system. Plan 2–3 days for a non-trivial migration (5K+ documents). If you're building a new project, choose the CMS upfront and stick with it for 12–24 months before reconsidering.

Six FAQs

Can I use Sanity + self-host?

No. Sanity is cloud-only (Sanity.io hosts your backend). If you need self-hosted with Sanity's features, use Strapi or Payload instead.

Is Strapi harder to deploy than Payload?

Not really. Both require a Node.js app + Postgres database. Deployment is similar (Railway, Render, Docker, VPS). Payload might feel slightly more integrated (since it's all TypeScript), but both are self-hosted and require the same infra footprint. Strapi has more pre-built plugins, making some deployments faster.

Can I use Sanity free tier forever without upgrading?

Yes, if you stay under 1GB assets and don't need team member seats. For a blog or marketing site, the free tier is genuinely infinite. Once you hit 10+ editors, upgrade to Pro ($99/month).

Does Payload have plugins like Strapi?

Yes, but fewer. Payload's ecosystem is younger. Most customization happens via React components and hooks, not separate plugins. If you need a pre-built plugin, Strapi likely has it. If you need full control, Payload is more flexible.

What if I need real-time sync on Strapi or Payload?

Add webhooks (Strapi and Payload support these) that trigger a rebuild on your frontend (Netlify/Vercel). This is near-real-time (seconds), not instant. For true real-time, upgrade to Sanity or roll your own WebSocket layer (not trivial).

Can I use Sanity + Strapi together?

Absolutely. If you need Sanity for marketing content and Strapi for custom data (inventories, orders), federate across both. Use Astro or Next.js to fetch from both APIs and render. The frontend doesn't care where content comes from.

The Bottom Line

Choose Sanity if you're optimizing for non-technical editors, real-time collab, and you have $99/month budget. Choose Strapi if budget is zero and you're comfortable self-hosting. Choose Payload if you need a custom admin UI and want TypeScript control throughout. At Aidxn, we default to Sanity for client marketing sites (because editors matter), Strapi for cost-sensitive internal tools, and Payload when custom workflows justify the complexity. All three are production-ready. The decision is mostly about: team skill (non-tech vs dev-led), budget (free vs $99/month), and infrastructure tolerance (cloud vs self). Measure your content complexity, editor count, and infrastructure comfort, then pick accordingly. For full-stack SaaS architecture consulting with headless CMS integration, see Aidxn Design pricing, or read more on building with Astro + Sanity at deploying content sites.