Seen on top review platforms
Headless commerce splits the commerce engine (products, orders, customers, pricing, checkout) from the front-end customers actually see. The two communicate via APIs. One commerce engine can feed a website, a mobile app, a kiosk, a marketplace integration, or any other channel that consumes an API. That’s the benefit. The cost: you’re now running and maintaining two systems instead of one, with all the deployment and monitoring overhead that implies.
Headless isn’t always the right answer. For a single-storefront business that doesn’t need front-end performance beyond what Shopify or WooCommerce already delivers, the added complexity often outweighs the benefit. We scope this honestly in discovery, not after launch. If a classic Shopify or WooCommerce build is the right fit, we’ll say so, and you can find that work in our eCommerce development service.


Theme-based storefronts work well until they don’t. When you need a layout the theme can’t model, when your plugin stack starts breaking on update, when your team spends more time fighting the platform than building features. A custom headless front-end gives you a layer you actually own and can change without breaking the commerce logic underneath.
When you sell on a website, a mobile app, marketplace listings and physical retail, inventory and price drift becomes a daily problem. A headless setup with a single commerce engine as the source of truth means every channel reads from the same data. Stock available on the website matches stock available in the app, because both read from the same API. The drift gets caught at the data layer, not in customer service tickets.

The full replatform every three years is the eCommerce industry’s running joke. Headless reduces that cost because you can change the front-end without rebuilding the commerce engine, or swap the commerce engine while the front-end stays in place. Not a free pass, you’re still maintaining two systems, but the cost of each change is significantly lower than rebuilding everything.
Every project runs in two-week sprints with weekly demos. The six steps below describe what happens in each phase. Most projects compress or expand individual phases depending on whether the commerce engine is new or existing, how messy the catalogue migration is, and how many channels the front-end needs to support.
01
We map the channels you’re selling on (website, mobile app, marketplaces, retail), the traffic profile (steady, seasonal, unpredictable peaks), and the integrations needed (ERP, PIM, marketing automation, fulfilment). The output is a stack proposal: which commerce engine, which front-end framework, which CMS, which CDN. We pick based on the actual workload, not on what’s trendy this quarter.
02
Product data model (variants, attributes, taxonomies, B2B pricing tiers where relevant), pricing model (regional pricing, customer-specific pricing, promotional logic), and content model in the headless CMS that wraps the commerce data. We test the model against your real existing catalogue before any code gets written, because catalogue migration is where most headless projects lose time.
03
The API layer the front-end consumes. For Shopify Hydrogen we use the Shopify Storefront API. For WooCommerce we use the REST or Store API. For custom commerce engines, we expose REST or GraphQL endpoints with explicit contracts. Authentication, rate limiting and webhook handling get configured properly so the integration layer doesn’t quietly break when an upstream API updates.
04
Front-end built in Next.js, Nuxt, Remix or SvelteKit depending on the project. SEO-aware by default: server-side rendering for product and category pages, structured data, fast time-to-first-byte. Mobile-first, since most commerce traffic is mobile. Image optimisation via the framework’s built-in pipeline rather than runtime processing.
05
Headless CMS layer (Contentful, Storyblok, Sanity, Strapi or Directus) for content that wraps the commerce data: product copy, category descriptions, marketing pages, blog posts. The CMS feeds the front-end via its own API. Editors get a familiar admin interface and don’t need to touch the front-end code.
06
Load testing on the API and the front-end under projected peak traffic. Security testing including dependency scanning and OWASP-aligned checks. Edge caching configured for the cacheable parts of the catalogue. Launch with zero downtime via blue-green or rolling deploy. After launch we measure Core Web Vitals, conversion paths and integration health on a sprint cadence.
We’ve been building and maintaining digital products long enough to know what breaks, what scales, and what “urgent” actually means.
Studio Ubique has been building eCommerce since 2012, with a mix of traditional Shopify and WooCommerce stores and headless setups where the project genuinely benefits from the added flexibility. We’re honest about when headless makes sense and when it adds complexity without value. Books a discovery call and we’ll walk through what would actually fit your store.
Most things you’re wondering about are answered here or on the FAQ page. If something’s missing, reach out, humans deserve clarity too.
Headless commerce means splitting your commerce engine (products, pricing, orders, checkout) from the front-end your customers see. The two communicate via APIs. A single commerce engine can feed multiple front-ends: a website, a mobile app, a marketplace integration, a kiosk in a physical store. The benefit is flexibility and front-end performance. The cost is added complexity: two systems to maintain instead of one.
Headless makes sense when one of these is true: you need front-end performance beyond what classic Shopify or WooCommerce can deliver, you’re publishing to multiple channels and want a single source of truth for product data, your design needs go beyond what theme frameworks allow, or you’re planning to swap commerce engines later and want to decouple the front-end from that decision. For single-storefront stores that don’t have those pressures, classic Shopify or WooCommerce is faster to build, cheaper to maintain, and easier to find developers for. We’ll tell you which fits in discovery, not after launch.
The choice usually comes down to four questions. First, what does your front-end need to do that themes can’t handle? If “nothing material”, classic platforms win on cost and maintainability. Second, how many channels does the commerce data need to feed? One channel rarely justifies headless complexity. Five channels often does. Third, what’s your team’s operational maturity? Headless means more moving parts in deployment, monitoring, and incident response. Fourth, what’s your budget for ongoing development? Headless costs more to maintain because you’re maintaining two systems.
From our case work, most clients land on classic WooCommerce or Shopify because the four pressures above don’t all apply. Headless wins when at least two or three of them do. We’ve seen prospects pushed toward headless by an agency before understanding whether they actually need it, then end up with a stack that’s harder to maintain than the problem they were solving. We try not to do that.
Five main choices depending on the project. Next.js for most stores because the ecosystem is mature, server-side rendering is well-supported, and the Vercel deployment path is clean. Nuxt when the team prefers Vue and the same SSR and edge benefits matter. Remix when nested routing and progressive enhancement fit the project shape. SvelteKit for projects where front-end performance is the dominant requirement and the team can support a less common framework. Astro for content-heavy commerce sites where most pages are static or near-static.
We don’t push a fixed answer because that often becomes the wrong answer two years later. The deciding factors are your team’s existing JavaScript expertise (Next.js for React shops, Nuxt for Vue shops), your performance requirements, and which framework your hosting partner supports best. We document the choice in the architecture phase so the rationale is clear if you need to revisit it later.
For commerce engines: Shopify (via Hydrogen or the Storefront API) for stores that want the Shopify operational benefits with custom front-ends, WooCommerce (via REST and Store API) when WordPress sits next to the store and editorial flexibility matters, custom commerce engines built on Laravel or Node.js when off-the-shelf platforms can’t model the business logic. For specialised needs, we’ve also worked with Medusa as a self-hosted alternative, and we can integrate with enterprise platforms like commercetools or BigCommerce when those are already in place.
For headless CMS: Contentful for established commerce teams that value enterprise tooling, Sanity for projects where the content model is unusual and the editorial experience needs customising, Storyblok for projects where editors prefer a visual block-based interface, Strapi or Directus for self-hosted setups where data residency matters. Each has trade-offs around editor experience, pricing model, and integration capability. We pick based on your team and your content shape, not on which platform we’ve sold most recently.
SEO on headless commerce requires more deliberate setup than classic platforms because the front-end framework controls how pages are rendered for crawlers. Server-side rendering or static generation for product and category pages is non-negotiable. Structured data (Product schema, BreadcrumbList, Organization, FAQPage where relevant) gets generated from the commerce data automatically. Sitemaps generated dynamically from the catalogue so new products show up in search engines without manual updates. Time-to-first-byte and Core Web Vitals optimised from day one rather than as a post-launch project.
Common SEO failure modes we see on headless stores: client-side rendering on product pages that Google crawls slowly, structured data missing or implemented inconsistently across templates, sitemap not updated when products change, and migration losing URL equity because old URLs weren’t mapped to new ones. We handle these in the architecture and migration phases, not as last-minute fixes before launch.
Our hourly rate is €60-€65 across all roles (UX, frontend, backend, project management, QA), with our team split between Zwolle and Chandigarh. A focused Shopify Hydrogen build typically runs €20,000 to €50,000 for a single-storefront project, depending on catalogue complexity and integrations. WooCommerce headless builds sit in a similar range. Custom commerce engines with headless front-ends run €40,000 to €100,000+ depending on the business logic complexity. B2B and marketplace headless projects are usually at the higher end because of the catalogue and pricing complexity.
Timelines run from 10 weeks for a focused Shopify Hydrogen build to several months for custom commerce engines. The biggest scope variables are catalogue size and complexity, the number of integrations (ERP, PIM, marketing automation, fulfilment), multi-region requirements, and whether B2B or marketplace logic adds layers to the commerce engine. Schedule a discovery call to walk through what you actually need before any number gets put on paper.
After launch we offer ongoing support and maintenance through three packages: Care (4 hours per month, 24 working-hour response), Growth (8 hours per month, 8-hour response) and Partnership (16 hours per month, 4-hour response). Pricing starts at €240 per month, three-month minimum term, then monthly cancellable with one month notice.
Headless stores need more ongoing attention than classic platforms because there’s more surface area for things to break. Front-end framework updates, headless CMS version bumps, commerce engine API changes, dependency updates across both systems, performance tuning as the catalogue grows. For teams shipping continuously (new campaigns, seasonal launches, A/B tests, regional expansions), we run a dedicated-developer model where a fixed-capacity developer (40 to 160 hours per month) works as an extension of your team. Most of our long-running headless clients land on this model after the first three to six months.
Book a quick 30 min video call, we will show you exactly what to fix. We reply within 24 hours.