Skip to content
PRSINDIA

MACH · Composable · Headless

Headless & Composable Commerce

Headless commerce decouples a fast custom storefront from the commerce engine; composable commerce assembles a best-of-breed MACH stack behind it. We build both — Next.js storefronts on commercetools, Medusa or a headless Shopify, with search, CMS and payments composed — for omnichannel brands that have genuinely outgrown a monolith, and we will tell you when you have not.

  • Next.js storefronts decoupled from the commerce engine
  • Composable MACH stack: best-of-breed, API-first, assembled
  • One catalogue and cart across web, app, kiosk and ONDC
  • commercetools, Medusa or a headless Shopify / BigCommerce engine
Why headless & composable

For the brand that sells everywhere at once.

There is a point at which one platform trying to be your storefront, your catalogue, your search, your content system and your checkout stops being an advantage and starts being a ceiling. Headless commerce breaks the storefront off so you can build any experience you like on top of one engine. Composable commerce goes further and lets you assemble a best-of-breed stack — commerce, search, content, payments — each chosen on its merits and swappable without a replatform. That freedom is real, and so is its cost. This architecture earns its keep for omnichannel brands selling across web, app, in-store, marketplace and ONDC, with the engineering capability to run a distributed stack. For everyone else it is expensive complexity, and the most valuable thing we do on the first call is tell you honestly which one you are.

Talk to a commerce architect
MACH
The composable model

Microservices, API-first, Cloud-native, Headless — best-of-breed components assembled, not one platform doing everything.

0engine
Many storefronts

One catalogue and cart serving web, app, kiosk, marketplace and ONDC from a single commerce backend.

0
Vendor lock-in

Any component — search, CMS, payments — swappable without replatforming the whole store.

BFF
One clean API

A backend-for-frontend presents a single stable API so the storefront never juggles five services itself.

How we actually approach headless and composable

Composable commerce is the most oversold architecture in retail technology and, for the right business, one of the most transformative. The gap between those two statements is entirely about whether you needed it. Here is how we decide, and how we build it when the answer is yes.

We argue you out of it first

The honest starting position is that most businesses asking for composable commerce would be better served by a well-built monolith or a simple headless setup. A composable stack multiplies the number of systems you run, monitor, secure and keep in sync, and it demands a platform engineering capability that many teams do not have and should not have to build. So the first thing we do is try to talk you out of it — and if the reasons survive that, you can trust the build, because it was justified rather than sold.

Headless first, composable only if warranted

Going headless — a custom Next.js storefront on top of a commerce engine — delivers most of the front-end benefit people actually want: a fast, bespoke experience, Core Web Vitals you control, and one design system across touchpoints. You can do this on top of Shopify or BigCommerce and keep their managed reliability. Full composability — swapping the single engine for assembled best-of-breed services — is a further step you take only when a single engine genuinely cannot serve your model, or when being able to replace any component without a replatform is worth real money to you.

The engine choice: managed MACH or open-source you own

When composable is warranted, the central decision is the commerce engine. commercetools is the reference managed MACH platform — API-first, powerful, with a licence to match — and it fits large enterprises that want the capability without running the infrastructure. Medusa is an open-source commerce engine you self-host and own outright, which fits teams that want composability without a per-order licence and have the engineering to run it. We build on both, and the right answer is a function of your scale, your team and your appetite for licence versus ownership.

Orchestration is the whole discipline

The failure mode of composable commerce is the distributed monolith: five services that must all be up for anything to work, with no clear owner of consistency and no visibility when one is slow. We avoid it deliberately. A backend-for-frontend gives the storefront one stable API. Integrations are asynchronous and idempotent so a slow provider cannot topple checkout. One component owns data consistency between engine, search index and CMS, with reconciliation rather than hope. And distributed tracing runs across the whole stack. Composability without this is all of the cost and none of the benefit, which is exactly the outcome this page exists to help you avoid.

The honest part

When to go composable — and when to stay put.

  Go headless / composable Stay monolithic
True omnichannel: web, app, in-store, marketplace, ONDC Yes. One engine serving many touchpoints is exactly the case it was built for. A single web storefront gains little and pays a lot for the flexibility.
You have a platform engineering team Yes. A distributed stack needs people to run it well. Without that capability, a monolith or managed headless is far safer.
Custom front-end experience matters Go headless — but you may not need full composability to get it. A themed monolith storefront is enough for most brands.
Small catalogue, simple model, tight budget No. This is expensive complexity you do not need. Shopify, Magento or WooCommerce. Ship and grow first.
You fear vendor lock-in at scale Composable lets you swap any component without a replatform. At smaller scale, lock-in is a cheaper problem than a distributed stack.
Fastest time to launch No. Assembling and orchestrating a stack takes real time. A hosted monolith is live in a fraction of the time.
What we build

Headless and composable work we take on.

From a headless storefront on your existing engine to a fully assembled MACH stack.

Headless storefronts

A fast, custom Next.js storefront on top of Shopify, BigCommerce or a dedicated engine, via the Storefront API — the highest-value first step.

Composable architecture

A full MACH stack assembled — commerce engine, search, CMS, payments — each chosen on its merits and swappable without a replatform.

commercetools builds

The reference managed MACH platform configured and integrated, for enterprises that want the capability without running the infrastructure.

Medusa builds

An open-source commerce engine you self-host and own outright, for teams that want composability without a per-order licence fee.

Backend-for-frontend

An orchestration layer that gives the storefront one clean, stable API instead of making it juggle five services directly.

Search & discovery

Algolia or a comparable engine wired in for instant, typo-tolerant, faceted search and merchandising across every touchpoint.

Omnichannel & ONDC

One catalogue and cart serving web, app, kiosk, marketplace and the ONDC network from a single commerce backend.

Observability & tracing

Distributed tracing and monitoring across the whole stack, so a slow checkout points to a service rather than a guess.

Monolith to headless migration

A staged move off a monolith, storefront first, with URLs 301-mapped and the engine decoupled without a big-bang cutover.

India, specifically

Composable commerce in the Indian context.

India adds touchpoints and compliance that make the omnichannel case stronger — and the orchestration discipline more important.

  • ONDC is a composable network

    The Open Network for Digital Commerce is itself an API-first, decoupled model. A composable stack participates in ONDC naturally, as one more touchpoint on the same engine.

  • UPI and Razorpay as a layer

    Payments are a swappable component — Razorpay, Cashfree or a stack of providers — with UPI intent, cards and wallets behind one clean payments API.

  • GST across touchpoints

    One tax and invoicing service applying HSN-based CGST/SGST/IGST and e-invoice IRN consistently, whether the order came from web, app or ONDC.

  • Web, app and in-store as one

    A single catalogue and cart behind a headless engine keeps online and physical retail genuinely unified rather than reconciled after the fact.

  • WhatsApp as a channel

    Conversational commerce and notifications on the WhatsApp Business API, treated as another front end on the same commerce engine.

  • Data residency and the DPDP Act

    Where regulation or a buyer requires it, components are chosen and hosted so customer data stays in-region and the compliance answer is honest.

How we ship it

Storefront first, engine decoupled, never big-bang.

A composable migration that tries to replace everything at once is a composable migration that fails. We stage it.

  1. 01

    Justify the architecture

    Weeks 1–2

    We pressure-test whether you need composable at all, model the cost against a monolith or simple headless, and only proceed on the reasons that survive. The output is a decision you can defend, not a build you were sold.

  2. 02

    Decouple the storefront

    Weeks 3–10

    A Next.js storefront goes in front of the existing engine via its Storefront API, with URLs 301-mapped. You get the front-end benefit immediately, before any back-end is touched.

  3. 03

    Compose the back end, one service at a time

    Weeks 8–22

    Search, CMS and payments are introduced as swappable components behind a backend-for-frontend, each with its own consistency owner and idempotent integration — never all at once.

  4. 04

    Instrument, and add touchpoints

    Weeks 20–34

    Distributed tracing and reconciliation across the stack, then new channels — app, ONDC, in-store — added onto the same engine now that the foundation is trustworthy.

The stack

What a composable build is assembled from.

Best-of-breed components chosen on their merits, connected through a disciplined orchestration layer.

Next.js
React
TypeScript
Vercel / Edge
The trap

The distributed monolith, and how we avoid it.

The worst outcome of a composable project is not a build that fails to ship. It is one that ships and then quietly becomes a distributed monolith: five services that must all be healthy for anything to work, no single owner of data consistency, and no visibility into which one is slow when a customer complains. All of the cost of composability, none of the benefit.

We design against it from the first sprint. A backend-for-frontend so the storefront depends on one API, not five. Asynchronous, idempotent integrations so a slow provider degrades gracefully instead of taking down checkout. One component that owns consistency between the engine, the search index and the CMS, reconciling rather than hoping. And tracing across the whole stack so slowness has an address. This discipline is the actual deliverable — the component list is the easy part.

  • A backend-for-frontend, so the storefront sees one API
  • Idempotent, async integrations that degrade gracefully
  • One owner of cross-service data consistency
  • Distributed tracing so slowness has an address
FAQ

Headless and composable, answered straight.

Still have a question?

Headless means decoupling the storefront from the commerce engine and connecting them over an API, so you can build any front end on top of one backend. Composable goes further: instead of one platform behind that API, you assemble a best-of-breed stack — a commerce engine, a separate search provider, a separate CMS, a separate payments layer — each chosen on its merits and connected via APIs. Composable is usually described as MACH: Microservices, API-first, Cloud-native, Headless. Headless is a decision about the front end; composable is a decision about the whole back end. You can be headless without being composable, and we often recommend exactly that.

Probably not yet, and that is the most useful thing we can tell you. Composable is genuinely powerful and genuinely expensive — in engineering, orchestration, and the number of moving parts to monitor and keep in sync. It earns its cost for large omnichannel businesses selling across web, app, in-store, marketplace and ONDC, with the platform engineering to run it. For most stores, a well-built monolith or a simpler headless setup delivers most of the benefit at a fraction of the risk. We lead with that honesty because a composable build sold to a business that did not need one is a very expensive mistake.

A typical stack is a Next.js storefront, a commerce engine (commercetools for managed MACH, Medusa for an open-source engine you own), a dedicated search layer such as Algolia, a headless CMS such as Sanity or Contentful, and a payments layer such as Razorpay or Stripe — orchestrated through a backend-for-frontend that presents one clean API to the storefront. The point of composability is that any component can be swapped without replatforming the whole store, so you are never again captive to a single vendor's roadmap.

Yes, and for many businesses this is the sweet spot: keep the managed reliability of Shopify or BigCommerce as the engine, and put a fast, custom Next.js storefront in front via the Storefront API (Shopify Hydrogen or BigCommerce Catalyst are the vendor-blessed paths). You get the bespoke front-end experience of headless without the full complexity and cost of a composable back end. It is often the right first step, and sometimes the right destination — you do not have to go all the way to MACH to get most of what you came for.

By treating orchestration and observability as first-class from day one. A backend-for-frontend gives the storefront a single stable API rather than five services to juggle. Integrations are asynchronous and idempotent so one slow provider cannot take down checkout. One component owns data consistency between engine, search index and CMS, with reconciliation rather than hope. And distributed tracing runs across the whole stack, so slowness points to a service rather than a guess. Composable without this discipline is how you get a distributed monolith with all the cost and none of the benefit.

A headless Next.js storefront on an existing Shopify or BigCommerce engine is typically 10 to 16 weeks from around INR 14,00,000. A full composable build — engine, search, CMS and payments assembled with orchestration and observability — runs 20 to 36 weeks and starts around INR 30,00,000, plus the SaaS licences of the components you choose. The variable is how many systems are composed and how omnichannel you truly are. We scope that hard in a paid discovery, because this is exactly the architecture where a number given too early is one someone regrets.

Considering headless or composable? Let us pressure-test it first.

Tell us your touchpoints, your catalogue and your team. A commerce architect replies within one business day — and if a monolith or a simple headless setup serves you better, we will say so before you spend on a MACH stack you did not need.

Proof

Shipped, measured, still running.

All case studies

Swasthya Sarathi

A healthcare-companion platform for Swasthya Sarathi

A website and mobile app development project for a multi-service healthcare companion — helping peop...

Read it

MV Tech Education

A course and admissions platform for MV Tech Education

A website development project for a Bihar vocational institute — a course-catalogue and admissions s...

Read it

Patna Taxi

A booking-focused taxi website for Patna Taxi across Bihar

A website development project for a Patna and Muzaffarpur cab operator — a fast, mobile-first taxi-b...

Read it

Let's talk headless & composable commerce

Bring us the hard version of the problem.

A senior engineer reads every enquiry. You'll get a real answer — scope, risk and a number — within one business day.