Why We Chose Payload CMS for a Next.js Blog (And What It Cost Us)
Why We Chose Payload CMS for a Next.js Blog (And What It Cost Us)
We rebuilt this blog in 2026 on Next.js, React, Payload and Postgres, running as a single container in the cloud. This is the decision log: what we compared, what we picked, and, more usefully, the four places where the choice cost us real time.
Most "why we chose X" posts are written the week the migration lands, while everyone still likes the decision. This one includes the parts that scarred.
Key Takeaways
- Payload 3 installs into an existing Next.js app rather than running beside it, which collapses the CMS and the website into one deploy unit and one TypeScript project.
- Defining our content model cost 483 hand-written lines. Those lines generated 25,717 lines of TypeScript types and SQL migrations, 86.5% of everything added to the source tree.
- The frontend, not the CMS, was where the work went: 3,529 hand-written lines versus 483 for the entire content model.
- The real costs were a rich-text migration that broke the editor, an access-control gap around publishing, and a deployment model that ruled out build-time rendering.
- Payload was acquired by Figma on 17 June 2025. That is a governance question worth pricing in, not a dealbreaker, but it changed how we thought about hosting.
The stack we actually shipped
Layer | Choice |
|---|---|
Framework | Next.js (App Router) |
UI runtime | React (Server Components) |
CMS | Payload 3 |
Database | Postgres |
Rich text | Lexical |
Media | Cloud object storage |
Styling | Tailwind CSS |
Hosting | Containerised, self-hosted in our own cloud |
Next.js 16 mattered to the decision more than a framework release usually would. In that version Turbopack became the default bundler, React Compiler support went stable, and the Build Adapters API stabilised so that non-Vercel deployment targets get the full feature set (Next.js 16 release notes, retrieved 2026-08-13). That last item is why self-hosting stopped feeling like swimming upstream.
Why a TypeScript-native CMS won
The decision came down to one architectural question: should the CMS be a separate service the website talks to over HTTP, or part of the website?
Payload 3 answers this by installing directly into an existing Next.js app, sharing its server, routes and build process (Payload 3.0 announcement, retrieved 2026-08-13). The admin panel is a route group in our own app. There is no second service to deploy, no second Dockerfile, no CORS negotiation between two origins we control.
The practical payoff is the Local API. Payload's docs describe it as direct-to-database access with no HTTP overhead, callable from any server context including React Server Components (Payload Local API docs, retrieved 2026-08-13). In an RSC-first codebase this removes an entire layer: a server component fetches posts with a function call rather than issuing a network request to a CMS that then queries a database.
Payload stays database-agnostic through adapters for Postgres, MongoDB and SQLite (Payload Postgres docs, retrieved 2026-08-13). We picked Postgres for two real reasons and one non-negotiable one. The real ones: we wanted relational integrity across the taxonomy, and managed Postgres was already part of our infrastructure. The third: it is the best database in the world :)
Apparently we are not alone in that last one , Postgres is the most-used database among professional developers, at 58.2% (Stack Overflow Developer Survey 2025, retrieved 2026-08-13).
The number that justified the choice
We started from the official Payload website template and measured everything we added on top of it. Of 29,729 inserted lines, 25,717 were generated: the TypeScript type definitions plus SQL migrations. Only 4,012 lines were hand-written.
That ratio is the argument for a schema-first CMS stated as a measurement. We describe a collection once in TypeScript, and Payload derives the database schema, the migration, the admin UI, the REST and GraphQL endpoints, and the types the frontend imports. Rename a field and the compiler tells you every template that breaks.
Our finding: the entire content model, six collections, nine blocks, the access rules, the plugin wiring and the root config, came to 483 hand-written lines. The website built on top of it took 3,529.
If you are evaluating a headless CMS on how pleasant its content modelling is, you are optimising the small number. The interesting question is what the CMS does to the cost of the frontend, and here, having the types and the query layer in-process was worth more than any admin-panel feature.
The alternatives we reviewed
Payload was not the obvious answer at the start. Three other options got real consideration, and a fourth category was ruled out by a constraint rather than by comparison.
Option | Runtime | Deploy model | Where it lost for us |
|---|---|---|---|
Payload | TypeScript / Node | Inside the Next.js app | — |
Strapi | TypeScript / Node | Separate service | Types and queries stop at the HTTP boundary |
Wagtail | Python / Django | Separate service | Second language and runtime to maintain |
Ghost | Node | Separate service | One install per language |
Hosted SaaS | Vendor-managed | Vendor's cloud | Self-hosting was a requirement |
Strapi
Strapi is the mature default in this space, with an MIT-licensed core and a large plugin ecosystem. It lost on architecture rather than quality. Strapi runs as its own service with its own admin panel, which means the website talks to it over HTTP, and the specific thing we wanted most, generated types and a direct query layer available inside React Server Components, is exactly what a separate-service CMS cannot offer. You get an API client instead. That is a perfectly reasonable trade, and the right one if you are feeding several frontends from one backend. We were feeding one.
Worth knowing before you commit: SSO, audit logs and advanced role-based access control sit in the paid Enterprise Edition (Strapi SSO documentation, retrieved 2026-08-13).
Wagtail
Wagtail describes itself as the leading open-source Python CMS, built on Django (wagtail.org, retrieved 2026-08-13). It is genuinely excellent, and its StreamField block editor is a more mature take on structured content than most of what the JavaScript ecosystem has produced.
It lost for a reason that has nothing to do with its merits: it would have introduced a second language and a second runtime. Types do not cross that boundary. We would have been maintaining a Python service.
If our team were Python-first, this is very likely the row we would have picked. The best CMS for a team is heavily a function of what that team already runs in production.
Ghost
Ghost deserved the most serious look of the three, because it is the only one that is not a general-purpose CMS pretending to be good at blogs, it is a blogging platform, open source and self-hostable, with newsletters, memberships and subscriptions built in rather than assembled. Choosing it would have deleted most of those 3,529 frontend lines. That is a real offer and we did not dismiss it lightly.
It came apart on languages. This blog runs English and Spanish from one instance, and Ghost's own documentation recommends the opposite approach: "one Ghost install per language. Our experience shows that this approach is not only the easiest to get off the ground, but it's also the most sustainable long-term." The same page notes that Ghost Admin lacks internationalisation support (Ghost translation FAQ, retrieved 2026-08-13).
Two installs means two databases, two deploy targets, two upgrade cycles, and a taxonomy that has to be kept aligned by hand across both. Against that, one Payload instance with locale-aware fields and a fallback to the default language was not a close call.
The honest version: if this were an English-only blog, Ghost would have been a genuinely hard choice to argue against, and the article you are reading might have a different title.
Hosted SaaS
We did not put platforms like Sanity or Contentful through a deep evaluation, because self-hosting was a requirement rather than a preference, and that removes them by definition. The distinction is sharper than the marketing suggests. Sanity's own FAQ answers the self-hosting question with "kind of": the Studio can be self-hosted, "but the Content Lake where data is stored must be hosted by Sanity" (Sanity FAQ, retrieved 2026-08-13).
That is not a criticism, a managed content backend removes an entire category of operational work, and for many teams that is the correct trade. It just was not available to us.
Where Payload actually hurt
Four things cost us real days.
1. The Lexical migration broke the editor, not just the content
We migrated from our previous blog, whose articles were stored as HTML. Payload stores rich text as Lexical JSON rather than markup (Payload rich text docs, retrieved 2026-08-13), so every article had to be converted into a node tree.
The conversion ran with Payload's full default feature set. The resulting documents therefore contained node types that our editor configuration did not enable, 883 list nodes across the corpus. Lexical does not degrade gracefully here: it throws error #17, "type not found", and refuses to render the entire document. Not the unknown node. The document.
The fix is a few lines, once you know:
UnorderedListFeature(),
OrderedListFeature(),
EXPERIMENTAL_TableFeature(), // 95 migrated articles contain comparison tables
The lesson is more general than the fix: the feature list you migrate with and the feature list you edit with must match, and a mismatch fails loudly and totally. Budget a full pass to inventory node types in your source content before you write the importer, not after.
This is also the honest counterpoint to the JSON storage model. Content in a Lexical tree is less portable than markdown in Git, you cannot review it in a pull request, and moving it elsewhere means writing a converter. Payload does ship markdown converters in both directions (Lexical converters docs, retrieved 2026-08-13), which softens this, but it is a real trade you are making for structured, block-aware content.
2. There is no publish permission
Payload's collection access control exposes the usual create, read, update and delete verbs, plus a few operational ones. It does not expose publish. So an editorial model where authors draft and only senior editors ship is not a configuration change, it is code you write.
We enforce it server-side, on the shape of the incoming write, and hide the control in the admin UI as well. The UI half is cosmetic; the server-side half is what actually holds.
The subtle part is that "unpublish" and "save a draft on top of a published post" can look almost identical in the payload of a write request, particularly with autosave enabled. Distinguishing them reliably, without breaking the internal scripts that legitimately save drafts on published documents, took more care than the headline rule did.
None of that is exotic, but it is the kind of thing that is invisible during evaluation and unavoidable in production. If your editorial workflow has more than two states, price in real hours.
This is the flip side of the licensing note above: where an open-core CMS would sell you the editorial workflow as an enterprise feature, Payload hands you the primitives and expects you to assemble it. Cheaper, and entirely your problem.
3. Localization config has to be duplicated by hand
Locales are declared in the Payload config. The frontend also needs the list, for routing, middleware and the language switcher, but it cannot import the Payload config, because that module gets pulled into client components and middleware.
So the list lives in two places and is kept in sync manually. It is a small wart, and we chose it deliberately over the alternatives, but it is the sort of thing that bites a new contributor who adds a locale in one file and cannot work out why the route 404s.
We also enabled locale fallback, meaning an untranslated field renders the default-locale value instead of a hole. That was not a stylistic choice: only a fraction of our migrated articles have Spanish versions, and a partially-translated corpus renders as Swiss cheese without it.
4. A database the build cannot reach rules out build-time rendering
Our database is not reachable from a build runner, a deliberate security posture, and an inconvenient one for Next.js. If no route can query the database while prerendering, build-time static generation is off the table. We render on demand instead, and lean on Payload's on-demand revalidation hooks to keep pages fresh when content changes.
This is not really a Payload problem. It is what happens when a framework that wants to render at build time meets infrastructure that will not expose a database to a build runner. But it is a predictable tax of self-hosting a Next.js CMS on private infrastructure, and it took several iterations to get the build and migration pipeline right.
The Figma question
On 17 June 2025, Figma announced it had acquired Payload, with the team joining the company. The announcement states plainly that "Payload will remain an open-source product" and that Figma will "continue to actively invest in and improve the open-source project" (Figma blog, retrieved 2026-08-13).
We took that at face value while still pricing the risk, for two reasons.
The first is the licence. The payload package is MIT-licensed. An MIT licence on code already published cannot be revoked; the worst realistic outcome is that future development slows or changes direction, and a community fork continues from the last release. That is a materially different risk profile from a proprietary SaaS backend, where a strategy change can end your access.
The second is that our deployment does not depend on the vendor at all. Notably, Payload's own production deployment documentation describes self-hosting and third-party platforms, "Payload can be deployed anywhere that Next.js can run", and makes no mention of a managed Payload Cloud offering (retrieved 2026-08-13). Whatever the status of that product, our answer is unaffected, because we were always going to run this ourselves.
If you are evaluating Payload today, the governance question is worth asking. But ask it precisely: what happens to me if this project stalls? For a self-hosted MIT deployment the answer is "we keep running the version we have." For a managed offering, the answer is different.
Who should not choose Payload
An honest decision log needs this section.
- You do not have TypeScript engineers. The content model is code. There is no visual schema builder to hand to a non-developer. If nobody on the team can comfortably write and review TypeScript, the main advantage inverts into a bottleneck.
- You want the CMS decoupled from the website. Payload 3's tightest integration is with Next.js. If you are serving several frontends in different frameworks from one content backend, a CMS that is deliberately a separate service fits better.
- Your content must live in Git as text. Lexical JSON is not reviewable in a pull request. A file-based CMS is a better match for docs-style content that engineers edit alongside code.
- You need SSO and audit logs on day one, with no engineering time. Payload gives you the primitives; assembling enterprise access control is your work.
What we would choose again
All of it, with one change: we would inventory the source content's node types before writing the migration rather than during it. That single step would have removed most of the pain described above.
The deeper reason the choice held up is the one the measurements show. A CMS is not really judged by its admin panel, that is the part you see during evaluation and stop noticing within a week. It is judged by what it does to the cost of everything built on top of it. Having the schema, the types and the query layer inside the same TypeScript project turned the content model into the cheapest part of the build.
That is the trade Payload offers: you accept that your CMS is code, and in exchange your CMS stops being a service you integrate with and becomes a library you call.
Frequently asked questions
Is Payload CMS free?
The payload package is MIT-licensed and free to self-host. Costs come from the infrastructure you run it on rather than from licensing.
Does Payload require Next.js?
Payload 3 is built to install into a Next.js app, and its Next.js package supplies the admin panel and HTTP layer. If you are not on Next.js, this integration is the main thing you would be giving up.
Can you use Payload with Postgres instead of MongoDB?
Yes. Payload supports Postgres, MongoDB and SQLite through database adapters, one per project. We chose Postgres for relational integrity across our taxonomy.
How hard is migrating to Payload from another CMS?
The data mapping is mechanical; the rich text is not. Converting HTML into Lexical JSON was the bulk of our effort, and a mismatch between the features used during conversion and those enabled in the editor prevents documents from rendering at all.
What happens to Payload now that Figma owns it?
Figma stated on 17 June 2025 that Payload remains open source and that it will continue investing in the project. Because the code is MIT-licensed and self-hostable, an existing deployment is insulated from changes in the vendor's commercial strategy.
Conclusion
Payload was the right call for this blog, and the reasons are measurable rather than aesthetic: 483 lines of content model generated 25,717 lines of types and migrations, and the frontend , not the CMS, absorbed the real work.
The costs were equally concrete. A rich-text migration that broke the editor outright, an editorial permission that had to be written by hand, a locale list duplicated across two files, and a deployment model that ruled out build-time rendering. None of those appear in a feature comparison. All of them appear in a sprint.
If you are making the same decision, the questions that actually discriminate are: does your team write TypeScript, does your content need to be portable as text, and are you self-hosting anyway? Answer those three honestly and the choice mostly makes itself.