What is a headless CMS?
A headless CMS is a content management system that stores and edits content but does not render it. The content is served over an API, and a separate front end, written in Astro, Next.js, a mobile app or anything else, decides what the page looks like. The head in headless is the presentation layer, and a headless CMS deliberately does not have one.
A traditional CMS answers a browser request with finished HTML. A headless CMS answers a program with JSON. Everything else about it, the content model, the editor, the roles, the review step, is the same work. Only the last hop changes.
- What it stores
- Structured content, as typed fields rather than pages of HTML.
- What it returns
- JSON over an API, to any client that can make a request.
- What it does not do
- Render the website. That is the front end’s job.
How does a headless CMS work?
A developer defines the content model: an article has a title, a slug, a cover image and a body, a product has a name, a price and a gallery. The CMS turns that model into an editing interface and into an API.
Editors fill the fields in and publish. Publishing writes a new version and makes it visible on the delivery API. The front end requests the content it needs, either once at build time for a static site or on each request for a rendered one, and turns the fields into markup.
Nothing in that loop knows what the page looks like. The same article can be a web page, a card in a mobile app, and a row in a newsletter, because the CMS returned fields rather than a layout.
- Model. Typed fields, defined once, shared by the editor and the API.
- Publish. A version becomes visible on the read-only delivery API.
- Fetch. The front end reads the fields at build time or per request.
- Render. The framework, not the CMS, decides what the page looks like.
Headless CMS vs traditional CMS
A traditional CMS owns the whole path from database to browser. That is why it is fast to start: install it, pick a theme, and there is a website. It is also why it is hard to leave, because the content and the templates are stored in the same place and the templates are written in the CMS’s own language.
A headless CMS owns only the content. The front end is a separate codebase in a language the team already uses, deployed the way they already deploy. A redesign replaces the front end and leaves the content untouched. A second channel is a second reader of the same API, not a second copy of the content.
What is a headless CMS good for?
Headless is the right shape when the content has to reach more than one place, when the front end is a real application rather than a set of pages, or when the team wants the site in their own stack with their own deploys.
It is also the shape that survives a rebrand. Design systems are replaced every few years. Content is not, and a headless CMS is the arrangement where those two facts do not fight.
Where headless goes wrong
Headless moves work rather than removing it. These are the cases where the trade is worth it, and the cases where it is not.
Wrong choice
- Nobody to build the front end Headless ships no website. Without a developer there is nothing to look at.
- Marketers who need the page A bare field form takes the layout away from the people writing for it.
- A brochure site that rarely changes Two systems and a build pipeline to publish four pages a year is a loss.
- Preview treated as an afterthought If drafts cannot render on the real front end, review moves to screenshots.
Good fit
- More than one channel A website, an app and a partner feed reading one set of records.
- A real front-end team People who already own a framework, a build and a deploy pipeline.
- Content that outlives designs A rebuild swaps the front end and leaves every record where it is.
- Performance is a requirement Static output at the edge, with no CMS in the request path.
Headless without losing the page
Two of the four failures above are the same failure: going headless takes the page away from the people who write for it. BetterCMS is headless by default and still gives them the page back.
-
One API, any front end
Published pages, entries and assets as JSON, read with an SDK or straight over HTTP from a workspace-scoped key.
-
Editing on the rendered page
The same records, edited in place on the real front end instead of in a bare form.
-
Preview that reads drafts
Draft mode renders unpublished work on the real front end, so review is not done on screenshots.
-
Typed content, typed client
The schema builder defines the fields once, and a codegen step turns them into the types the client returns.
-
Markdown for the other readers
Every page has a markdown twin and the site publishes an llms.txt index for answer engines.
-
Run it from an assistant
An MCP server, started with npx, gives an assistant the same operations the interface has, under the same permissions.
-
Headless means the CMS has no presentation layer. The system stores and edits content and serves it over an API, and a separate front end renders it. The head is the part that draws the page, and a headless CMS does not include one.
-
WordPress stores content and renders the site from its own themes. A headless CMS only stores content and returns JSON. WordPress can be run headless by ignoring its themes and reading its REST API, but the templating layer is still installed and still has to be maintained.
-
To set one up, yes. A headless CMS ships no website, so someone has to build the front end that reads the API. Day-to-day editing does not need a developer, and a hybrid system adds a visual editor so it does not need one for layout changes either.
-
A headless CMS does not improve SEO on its own. It helps indirectly, because a static or server-rendered front end can be faster than a plugin-heavy template, and because structured content makes correct titles, metadata and schema markup easier to generate. A slow client-rendered front end on a headless CMS ranks worse than a fast traditional one.
-
Not by itself, in most cases. Form submissions and site search are runtime features and a delivery API is read-only, so they are usually separate services. BetterCMS includes both, so a headless project does not need a second vendor for either.
-
Through draft mode. The front end runs in a mode that reads unpublished drafts using a secret kept server-side, so an editor sees the real page rather than a form or a screenshot.
Your next website starts here
See BetterCMS running on your pages, not on a sample site.