Storefront assessment
We measure your main templates on a phone against Google’s thresholds and count the apps loading scripts. Then we say stay on the theme or go headless, with the numbers. You receive: the assessment and a written recommendation.
Headless development
We measure your theme first, then build a storefront and content system in code you own, with Shopify or BigCommerce kept for products and checkout.
Get a stay-or-go recommendationPortfolio · selected work
Every site below is live and owned by the client. Each window is a capture of the real page, not a drawn mockup.
What the work is
Headless commerce keeps a store’s three jobs apart: showing products, holding content and taking orders. Each runs as its own system, and APIs pass data between them.
A Next.js application, written for your design and your products. Pages render on the server or ahead of time, so phones and crawlers get finished HTML, as they do from a theme.
A headless CMS such as Sanity holds the guides, size charts, landing pages and campaign copy. Editors publish without a developer, and the same entries can feed the site, email and an app.
Shopify, BigCommerce or your current platform keeps the catalog, inventory, cart and checkout. You keep the back office your team already knows, and the storefront reads from it through its API.
Two ways to build the storefront
Both are sound ways to run a store. We recommend the theme for a store that sells well on one, and the custom storefront when the limits below are costing you money.
| ThemeA template that runs inside your platform | Headless storefrontCustom code that reads from your platform | |
|---|---|---|
| Where the page is built | In the platform’s theme system, from sections and app blocks | In your own application, with markup written for each template |
| Design freedom | The layouts the theme and its section settings allow | Any layout your designer can draw, because the code is written for it |
| Content | Pages and blog posts inside the platform’s own editor | A separate CMS with structured entries that editors, email and apps can share |
| What it costs to run | The platform plan and the apps you install, with changes made in the theme editor | Hosting for the storefront and the CMS, plus developers for changes to the code |
| Best when | The catalog is small, the theme meets the design and nobody on staff writes code | Speed, design or several storefronts decide sales, and a developer is on call |
If a theme passes Google’s thresholds on a phone and your team can make the changes it wants, stay on it. A headless build adds a codebase to maintain, which makes sense only when the theme is the constraint. The first deliverable below is the measurement that settles it.
What the sources say
Each comes from Google, Shopify or the Next.js docs, with the page and the date we read it.
You build the frontend, and Shopify’s APIs supply products, the cart and checkout. Shopify’s Storefront API serves products, collections, search and the cart, then hands the customer to Shopify checkout. So the theme goes, and Shopify’s catalog, cart and checkout stay.
Each is judged at the 75th percentile of page loads, split by mobile and desktop. That means three in four real visits must meet the number, so a fast test on a developer’s laptop does not count. These are the targets our templates are built and measured against.
Google commissioned the study, and 55 and Deloitte ran it over more than 30 million sessions in late 2019. The sites ran in Europe and the United States. It reports an association from the sampled brands, so treat 8.4% as evidence that speed matters, not as a forecast for your store.
Google’s guide says those approaches make a site faster for users and crawlers, and that not all bots can run JavaScript. A storefront that ships finished HTML is readable by crawlers that do not run JavaScript. The guide does not say rendering is required for Google.
With time-based revalidation, the next visitor after the interval gets the stored page and a fresh version generates behind it. On-demand revalidation instead invalidates a path or a tag when your CMS or platform sends an event. That is how a price change reaches a stored page in seconds instead of at the next build.
The documentation says the default file-system cache belongs to each instance, and recommends a shared cache handler to coordinate. Hosting that manages this is one reason the written scope prices the hosting setup. On a theme, the platform handles it.
What the work includes
The written scope names the templates and platforms; each card ends with the file or account you keep.
We measure your main templates on a phone against Google’s thresholds and count the apps loading scripts. Then we say stay on the theme or go headless, with the numbers. You receive: the assessment and a written recommendation.
We build the home, collection, product and cart templates as a Next.js application that sends finished pages. Product data comes from your platform’s API. You receive: the application in a repository you own, and a staging site to review.
Guides, size charts, landing pages and banners move into a CMS with fields shaped for them, so editors publish without code. A publish refreshes the affected pages. You receive: the CMS project in your account and an editor guide.
We connect the storefront to your commerce platform for products, inventory, cart and the handoff to checkout. Webhooks refresh prices and stock on the stored pages. You receive: the integration code and a map of what syncs and when.
We keep existing paths wherever we can, redirect the rest with a map, and add product, price and availability markup to the new pages. Sitemaps are rebuilt. You receive: the URL map and a before-and-after crawl comparison.
Hosting, the repository, the CMS and the error monitor are set up in accounts in your name from day one. We write down how to deploy, roll back and renew. You receive: the logins, the runbook and a walkthrough with your team.
How it runs
You approve each template on staging before it goes live.
Storefront assessment
| Template | Mobile LCP, 75th percentile | Scripts from apps |
|---|---|---|
| Home | 3.4 s | 11 |
| Collection | 3.9 s | 13 |
| Product | 3.6 s | 14 |
| Cart | 2.8 s | 9 |
Our stack
What we build with, host on and monitor with. Pick one for the detail.
Next.js is a React framework that renders pages on a server or ahead of time and sends finished HTML.
It runs the storefront: collection and product templates, the cart and the refresh of stored pages when prices or content change.
Questions
Keep exploring
A site built on a stack your team can maintain.
Theme and app work in your own Shopify store.
Lean WordPress: few plugins, logged updates, backups you can restore.
A whole store, from platform choice to launch.
Research with your users, then designs developers can build.
A store inside your WordPress site, with tax and payments set up.
One page for one offer, built to match the ad.
A new design built from the pages, links and search clicks that already earn.
Updates, backups and checks, with a log you can read.
Start here
Tell us where your products live and what is slowing you down. We’ll send back a written recommendation and the measurements it rests on.