A direct-to-consumer home goods brand had a storefront built from a theme and fourteen apps, and it took about six seconds to load a product page on a mid-range phone. Most of its traffic was mobile, and most of it left. After sixteen weeks of headless commerce development, the same products on the same commerce platform load in under two seconds, marketing publishes without a developer, and mobile conversion has roughly doubled.
This is how that headless commerce development project was scoped, what we built, the one decision that shaped the timeline, and what we would change next time.
The situation
The brand sold through a mainstream commerce platform with a purchased theme. Over three years, apps had been added for reviews, bundles, upsells, a quiz, analytics and a page builder, each injecting its own scripts. The theme could no longer be edited safely. Marketing requests queued behind a single contractor, and the page-speed score was in the red on every test.
None of the apps was a bad choice on its own. Each solved a real problem in a week instead of a month. The cost showed up in aggregate. Several apps loaded their own copies of common libraries. Bundles and upsells each fetched product data separately, after the page had already rendered, so prices and buttons shifted as the page loaded. The page builder wrapped every section in extra markup. On a fast laptop on office Wi-Fi, the site felt acceptable. On a mid-range phone on a cellular connection, which is where most customers were, it did not.
The editing problem was just as expensive. A new landing page for a seasonal promotion meant a ticket to the contractor, a few days of waiting, and a risk that a change to one template broke another. In practice, marketing ran fewer campaigns than it planned because the queue made each one slow to ship.
The goal and the constraint
The goal was a fast storefront that marketing could run day to day, measured by load time and mobile conversion. The constraints: the commerce platform had to stay, because checkout, orders, inventory, subscriptions and the finance team's reports all lived there; the launch could not drop organic rankings on the brand's best product pages; and the budget was for one build, not a platform migration.
Those constraints ruled out the two options founders usually ask about first. Moving to a different platform would have meant migrating subscriptions, which is risky for a brand with recurring revenue. A failed card token migration means failed renewals and support tickets. A new theme on the same platform would have been cheaper, but the apps would have come back with it, and the speed problem with them. Keeping the platform as the backend and replacing only the storefront was the narrowest change that addressed both the speed and the editing problems.
What we built with headless commerce development
- Storefront: a Next.js application rendered at the edge, reading products, prices and inventory from the commerce platform's Storefront API and handing off to its hosted checkout. Every product page is statically generated and revalidated when inventory or price changes. The platform sends a webhook when a product updates, and the storefront regenerates only the affected pages. A visitor gets a prebuilt page from a nearby edge location instead of waiting for a server to assemble it.
- Content: Sanity as a structured CMS for everything that is not a product: landing pages, editorial, the quiz, bundles and promotions, with a visual preview and scheduled publishing. Pages are assembled from a fixed set of components, such as hero, product grid, comparison table and testimonial. Marketing can rearrange them freely but cannot paste in arbitrary scripts. That limit is deliberate.
- Replacing the apps: reviews, bundles and upsells rebuilt as first-party components reading from the platform's data, which removed eleven third-party scripts. The remaining three were loaded after interaction. Bundle prices are now calculated when the page is built, not after it loads, so nothing jumps on screen.
- SEO continuity: URL structure preserved exactly, redirects for the handful of changes, structured data for products and reviews, and the old and new sites run side by side for two weeks with a traffic split before cut-over. During the split we compared crawl errors, indexed pages and conversion between the two versions daily.
- Team and timeline: three engineers and a designer across eight sprints, with the marketing lead publishing test pages from sprint four. Sprints one to three covered the data layer, product page and cart. Sprints four to six covered the CMS, landing pages and app replacements. Sprints seven and eight were for SEO checks, the traffic split and cut-over.
Getting marketing into the CMS by sprint four mattered more than it looks. It surfaced missing components while there was still time to build them, and it meant the team that would run the site had used it for a month before launch.
The hard decision
Whether to keep the hosted checkout. A custom checkout would have allowed more control over the final step and removed the last platform-branded page. It would also have put payment handling, tax, fraud and subscription logic into our scope and the brand's PCI scope. We kept the hosted checkout, styled it to match, and spent the saved weeks on the product page and the cart. Checkout completion did not change; the gains came earlier in the funnel.
The reasoning came from the brand's own funnel data. Most visitors were leaving on the product page, not at checkout. A custom checkout would have consumed several sprints solving a problem the data did not show. It would also have left the brand with a payment flow to maintain, audit and test against every platform update. A hosted checkout typically keeps a merchant in the lightest PCI self-assessment category. A custom one that touches card data moves it into a much heavier one. For a brand of this size, that is an ongoing cost, not a one-time build.
Results
Product pages went from about six seconds to under two seconds on a mid-range Android phone, measured with field data from real visitors. Over the following quarter, mobile conversion rate roughly doubled against the same traffic mix, measured in the platform's own analytics. Organic traffic to the top product pages held through cut-over and grew modestly afterwards. Marketing published more than forty landing pages in the first two months without a developer request.
Two caveats are worth stating. Seasonality and ad spend can move conversion on their own, which is why we compared against the same traffic mix rather than the same calendar period. And we cannot attribute the gain to speed alone. A cleaner product page, stable prices and faster campaign launches all contributed. What we can say is that the direction was consistent and held across the quarter.
What we would do differently
Migrate the reviews earlier. The reviews app held four years of reviews behind an export that took the vendor three weeks to deliver, and the product pages launched with reviews for a week fewer than planned. Request every data export in discovery.
In practice, that means a list in week one: reviews with dates and photos, quiz responses and logic, bundle definitions, any customer data held by an app rather than the platform. Ask each vendor for a full export and a timeline in writing. If a vendor cannot export, you want to know before the build starts, not during sprint six.
How a project like this starts
With a performance audit of the current storefront that names each script and what it costs, and a content audit that names what marketing actually edits. Discovery then fixes the platform boundary, the CMS and the SEO plan, and ends in a scope with a fixed price. If your storefront is a theme and a pile of apps, tell us about it.
A typical discovery for a storefront of this size runs two to three weeks. It produces a list of what stays on the platform and what moves, the component set for the CMS, a URL and redirect map, and the data exports to request. That document is what the fixed price is based on.
Frequently asked questions
Did the brand leave its commerce platform?
No. Products, inventory, orders, subscriptions and checkout stayed where they were. Only the storefront changed. The finance team's reports and the operations team's order workflow were untouched, which kept training and risk close to zero outside marketing.
Can marketing still use apps?
For back-office tasks, yes. Anything that injects scripts into the storefront now goes through a review, because that is how the site got slow in the first place. The review is short: what the script does, what it costs in load time, and whether a component could do the same job.
What does a headless storefront cost to run?
Hosting and the CMS together cost the brand less per month than the apps it retired. The ongoing cost is a maintenance retainer for the code it now owns. That covers framework and dependency updates, platform API version changes and small feature requests, and it is the line item a brand should budget for before choosing headless.


