Composable | API-first
Decoupled storefronts on Next.js and React over GraphQL, built for the cases that justify them. The honest version of this service includes telling you when it does not.
In one paragraph
When one of four things is true: the frontend has performance requirements the platform theme cannot meet, the same catalogue has to serve several channels, the design genuinely cannot be expressed in the platform templating, or the organisation needs frontend and backend to release independently. When none of those is true, headless adds a build to maintain, a rendering layer to debug and a hosting bill, in exchange for architecture diagrams. A well-tuned Liquid theme or Magento frontend beats a badly built headless storefront on every metric a business cares about.
What this is
Headless is the most oversold architecture in commerce, which is unfortunate, because for the right store it is genuinely the correct answer. The problem is that the cases where it wins are specific and the pitch is general.
What a decoupled storefront actually buys is control over rendering, over the delivery of the frontend, and over the release cycle. If none of those three is currently a constraint, it buys complexity. The engagement starts by establishing which, and occasionally ends there.
What this page is not
This page is about building a headless storefront. If the decision itself is still open, that is an architecture question and worth answering before a line of code.
What usually brings this in
Core Web Vitals will not improve no matter what gets tuned.
The theme layer sets a floor, and paid traffic is being bought against a page that converts below what it should.
The same catalogue has to serve web, app and a marketplace feed.
Three teams maintain three versions of what is meant to be one product truth.
The frontend team waits on backend releases to ship a layout change.
Design iteration runs at the speed of the slowest deployment in the stack.
A previous headless build was started and is now half-finished.
Two storefronts to maintain, and the migration path was never written down.
What gets built
- The decision, before the build
- Which of the four justifications applies to you, what it is currently costing, and what the headless version would cost to run. Sometimes the output is a recommendation not to.
- Storefront architecture
- Next.js over the Storefront API or GraphQL, with routing, caching and revalidation designed against how your catalogue actually changes rather than copied from a template.
- Rendering strategy per route
- Static for the catalogue, incremental for what changes, server-rendered for what is personal. A single strategy applied to every route is the most common reason headless builds disappoint.
- Progressive migration
- Route by route where the risk profile demands it, so the old storefront keeps trading while the new one takes over in pieces.
- Core Web Vitals as an acceptance criterion
- Measured on real devices and real network conditions, written into the scope as a number rather than an aspiration.
Technologies
- Frontend
- Next.js
- React
- TypeScript
- Tailwind CSS
- Commerce APIs
- Shopify Storefront API
- Magento GraphQL
- REST
- Hydrogen
- Delivery
- Vercel
- Cloudflare
- ISR
- Edge caching
- Measurement
- Core Web Vitals
- Lighthouse
- GA4
- Real user monitoring
How delivery runs
Scope, in writing
What the work is, and what it explicitly is not. The second half is the one that protects both of us, and it is written before anything is quoted.
Architecture before code
The data model, the integration points and the failure modes, agreed on paper. Most of the expensive mistakes in commerce are made here and discovered six weeks later.
Build in reviewable slices
Work lands in increments you can see running, not in one drop at the end. You find out early if something is going the wrong way, which is when it is still cheap.
Test against the real thing
Production-shaped data, production-shaped traffic. A checkout that works on twelve test products tells you nothing about one carrying a hundred thousand.
Deploy, document, hand over
Release process written down, documentation aimed at your team rather than at me, and a defined window afterwards where fixes are mine.
Questions
- Will headless make our store faster?
- It can, and it is not automatic. Headless removes the ceiling the theme layer imposes; it does not deliver the improvement on its own. A poorly built headless storefront is comfortably slower than a well-tuned theme, and that outcome is common enough to plan against.
- Can we go headless gradually?
- Usually yes, route by route, with the old storefront serving everything not yet moved. It takes longer and costs more than a single cutover, and for a store with meaningful traffic it is almost always the right trade.
- What does headless cost to run afterwards?
- A frontend codebase that needs maintaining, a hosting bill that was previously inside the platform fee, and a team that needs frontend engineering available. That ongoing cost belongs in the decision, and it is the part most often left out of it.
- Does headless work with Magento as well as Shopify?
- Yes, over Magento GraphQL, and PWA Studio exists for it. The considerations differ: Magento gives more control over the API layer and more responsibility with it.
Describe what is in front of you and you get a written scope and a figure, usually within a few days of a short call. No charge for either.