Headless can unlock flexibility, performance, and frontend freedom. But those benefits do not arrive automatically when a team separates its CMS from its presentation layer.
I recently moderated a conference conversation with Danny Kinney and Alex Jones, Drupal architects at americaneagle.com, and Sandeep Mehta, CTO of Planeteria, also known as Digital Deployment. I wanted to move past the usual headless question of how we can build a faster or more flexible frontend and ask the questions that determine whether a decoupled architecture can actually work:
- What web problem are you solving?
- What should editors keep?
- How do the environments stay connected?
- Who owns the release when more than one system is involved?
- When is the added complexity not worth it?
The panelists’ answers made one thing clear: framework choice should expand what a team can do without fragmenting how that team operates.
Headless is a means, not a finish line
Considering a rebuild, the first question should be: what does this headless architecture make possible that your current approach cannot? It’s the question I often ask when evaluating teams’ enquiries about moving off their existing stack. Jones put it plainly:
The biggest issue we see is when headless is treated as the goal and not as a means to an end.”
— Alex Jones, Drupal Architect, americaneagle.com
For an Americaneagle.com client, the answer involved a large manufacturing site with thousands of products and demanding performance requirements. The team identified specific gains from decoupling Drupal and Next.js: more control over distributed caching, the ability to invalidate specific components instead of an entire page, access to frontend expertise without requiring deep Drupal experience, and an opportunity to improve the editorial experience.
For Planeteria’s municipal clients, the motivation was different. They valued WordPress because nontechnical teams could use it to add a press release, notification, or alert without dev help. At the same time, those clients had serious concerns about the security implications of exposing a WordPress login and database through the public-facing experience. The team kept WordPress as the editorial backend and used Next.js as the frontend, with the backend protected by controls such as firewalls or VPN access in some implementations.
That is what a good headless decision looks like: a response to a specific operational or user problem, not a technology badge.
Kinney also described how a platform can lower the barrier to testing that decision:
How Americaneagle.com kept Drupal useful for editors
A new frontend should not require a new editorial operating model by default.
Jones described a common concern with headless Drupal: teams may lose the editorial features that made Drupal useful in the first place. For a manufacturing client, americaneagle.com kept the CMS at the center of content management and used Next.js to improve what editors could see before publishing.
The team embedded previews of frontend components directly into Drupal’s node-editing experience. Editors could update a paragraph or form element and see how the change would render before saving. The team also explored the same approach with Layout Builder and Drupal Canvas.
The evaluation criterion is straightforward: Does the architecture improve the experience for developers and visitors without making content teams pay the transition cost?
How Planeteria kept WordPress familiar and changed public experience
Planeteria kept the editorial model its municipal clients already understood: Gutenberg blocks, custom fields, and familiar WordPress workflows. Next.js added the design and presentation layer.
It’s kind of having the best of both worlds: staying and using what you’re familiar with, what is easy to use, and having a powerful frontend, which is fast to load.”
— Sandeep Mehta, CTO, Planetaria
The important word is “both.” A decoupled architecture is not successful if it improves the public site while making the people who operate the content system less effective, or if it addresses one risk by creating an unowned release process.
The real headless challenge is keeping systems in sync
Once a project has a CMS and a separate frontend, the team has more than one application, release surface, and place for a change to fail. The environments have to move together.
Kinney described what changed when each pull request could produce a working environment: teams could run accessibility and performance tests, try an idea on a throwaway server, and make decisions with something real in front of them.
That workflow changes who can participate in review and when problems become visible. But a preview environment only helps if the CMS and frontend are connected to the right data and if someone owns the connection. The architecture may be split, but release responsibility can't be.
What looks fine in a browser can still be unfinished
Mehta shared a warning from a Next.js and WordPress implementation. After launch with one of his clients, the team learned that the site looked fast to human visitors but exposed very little content to crawlers because JavaScript was doing the work of loading the page. They corrected the implementation by rendering the content on the server.
The lesson is broader than one rendering method: production readiness has to be tested from the perspective of every important consumer—visitors, editors, reviewers, search systems, and the people responsible for recovery.
“Works on my machine” is not a release strategy.
The smallest useful first step is a real test
If a team is overwhelmed by the architecture, identify the specific experience headless would improve that the current CMS does not. Then test that use case in a real environment.
For one team, the answer was performance at scale. For another, it was frontend flexibility and a better public experience. The discipline is the same:
- Can the right people review the change?
- Can the CMS and frontend use the right data together?
- Can accessibility, performance, and content behavior be tested before release?
- Does everyone know who owns release and recovery?
Kinney brought a little more energy to the question: “As a more-or-less cowboy optimist, I’d say the biggest mistake is getting so overwhelmed that you never try.”
Know when the complexity is not worth it
Headless is not the right fit for every site. A small site, a simple implementation, or a system that depends heavily on plugins may not justify the added maintenance and release responsibility.
Kinney’s signal was refreshingly human:
The signal to rethink headless is when the PM starts worrying about timelines and overhead.”
— Danny Kinney, Drupal Architect, americaneagle.com
That is not an argument against Next.js, Drupal, WordPress, or headless architecture. It is an argument against choosing complexity without a clear payoff.
The goal is to make different choices work within a shared production discipline: review, testing, ownership, release coordination, and recovery. Pantheon’s current Next.js offering applies the Git-based Dev, Test, Live model used across its WordPress and Drupal workflows, while supporting incremental adoption rather than requiring a full rewrite. Learn more about Next.js on Pantheon.
Framework choice should create room to build better experiences. If you are evaluating a decoupled architecture, start with the operational questions.
Explore the guide to decoupled, governed, and stable deployments.