ChatGPT answers, unedited

If the goal is specifically to decouple checkout from the storefront—so checkout can evolve independently of your React/Next.js/mobile/other front ends—I’d shortlist commercetools, Saleor, and Medusa, with commercetools as the strongest enterprise choice.

My recommendation

1. commercetools — my default recommendation

This is probably the best match if "checkout should be its own capability" is an architectural requirement.

commercetools is API-first and explicitly designed around separating experience from commerce services. More importantly, its current Checkout product supports both a complete checkout flow and a Payment Only mode. The latter lets you own the checkout experience while commercetools handles payment processing and order creation. commercetools Documentation commercetools Documentation

That gives you architectures like:

                 ┌── Web frontend
                 ├── Mobile app
                 ├── Kiosk
                 └── Other channel
                         │
                         ▼
                 Checkout/BFF layer
                         │
              ┌──────────┴──────────┐
              │                     │
        commercetools           Payment/PSP
        Cart / Order             integrations
        Pricing / Tax
        Inventory

You can also have your BFF create checkout sessions, keeping credentials and authorization away from the browser. The Checkout Browser SDK then consumes the session. commercetools Documentation commercetools Documentation

The big advantage is that you don't have to choose between fully custom checkout and outsourcing checkout. You can move along that spectrum.

It also supports PSP integrations through Connect, including options such as Adyen, PayPal and Stripe integrations. commercetools Documentation

commercetools.com

2. Saleor — excellent if GraphQL is central to your architecture

Saleor is particularly attractive if you want the commerce backend to be essentially a headless commerce API with no assumptions about your frontend. Its platform is GraphQL-native, and it explicitly supports arbitrary frontend/BFF stacks. Saleor Commerce

I'd consider it seriously if your engineering organization is comfortable owning more of the application architecture.

saleor.io

3. Medusa — strongest if you want maximum code-level control

Medusa is compelling when "decoupled checkout" really means we want checkout business logic to be ours.

Its Store API exposes customer-facing commerce functionality including carts and checkout, and the platform is particularly suited to custom commerce workflows. Medusa Documentation

The tradeoff is that you're taking on more responsibility than with a managed enterprise platform.

medusajs.com

What I would not optimize for

I wouldn't start with Shopify Plus if the primary architectural goal is to make checkout a genuinely independent commerce service. Shopify is excellent when you want a managed commerce platform and a headless storefront, but its ecosystem naturally pulls you toward Shopify's checkout/payment model.

In contrast, commercetools gives you a much cleaner separation between:

experience → checkout orchestration → commerce engine → payment provider

That's the architectural boundary I'd want if you're expecting multiple frontends or potentially replacing the frontend entirely.

The key architectural decision

I'd actually separate two concepts:

Checkout UI ≠ Checkout service

Your frontend should ideally be responsible for:

• collecting/displaying customer information
• rendering shipping/payment choices
• presenting totals
• UX and experimentation

The backend checkout layer should own:

• cart validation
• pricing/promotions
• tax
• shipping eligibility
• inventory validation
• payment authorization
• order creation
• idempotency
• fraud/risk hooks
• checkout state

That way, replacing Next.js with a mobile app—or adding an in-store/AI channel—doesn't require rebuilding the transactional logic.

So, if you're an enterprise/mid-market organization and this is a strategic architecture decision, I'd choose commercetools. If you're an engineering-heavy team that wants to own the commerce engine, I'd choose Medusa; if GraphQL and API purity are particularly important, I'd put Saleor alongside it.

If you tell me your current stack, order volume, B2C vs B2B, payment provider, and how much checkout logic you need to customize, I can narrow this to a concrete architecture and platform choice.

If the goal is specifically “checkout must be decoupled from the frontend, with the freedom to build our own checkout UX and potentially change frontend stacks later,” I’d shortlist commercetools, Saleor, and Medusa—with commercetools as the enterprise default.

My recommendation

1. commercetools — my pick for enterprise

This is probably the cleanest match for your architecture.

commercetools is explicitly API-first/headless, and its current Checkout product supports both a complete checkout mode and a payment-only mode. That means you can either let commercetools provide checkout infrastructure or retain your own checkout experience while using its payment capabilities. commercetools Documentation Commercetools

The architecture I'd aim for is:

                 ┌─────────────────┐
                 │  Web Frontend   │
                 │  Mobile App     │
                 │  Kiosk / Other │
                 └────────┬────────┘
                          │
                     Checkout API
                          │
                 ┌────────▼────────┐
                 │  Commerce Layer │
                 │                 │
                 │ Cart            │
                 │ Pricing         │
                 │ Promotions      │
                 │ Inventory       │
                 │ Orders          │
                 │ Checkout        │
                 │ Payments        │
                 └─────────────────┘
                          │
               ┌──────────┴──────────┐
               │                     │
          Payment PSPs          OMS / ERP

The important thing is that checkout becomes a commerce capability rather than a frontend feature.

commercetools' Checkout APIs are directly accessible programmatically, and their documentation explicitly describes using them for custom integration solutions. commercetools Documentation

I'd choose this if you have: complex pricing, B2B, multiple markets/channels, multiple frontends, significant integration requirements, or a desire to move toward a broader composable architecture.

2. Saleor — strongest API-centric alternative

Saleor is particularly compelling if your engineering organization wants the commerce backend to be almost completely invisible to the frontend.

Its checkout API supports things like:

• anonymous checkout
• multiple payment gateways
• split payments
• split fulfillment
• multiple checkouts
• custom checkout completion flows
• stock reservation
• multi-fulfillment
• custom shipping
• single-page checkout

Saleor also describes its storefront and admin APIs as fully headless and GraphQL-native. Saleor Commerce Saleor Commerce

This is a particularly good fit if your team is comfortable owning more of the commerce architecture and wants GraphQL + open source + extensive checkout control.

3. Medusa — best if engineering control is the priority

medusajs.com is worth serious consideration if you want the commerce backend to behave more like an extensible application framework than a traditional SaaS commerce platform.

I'd favor it when the requirement is:

“We want to own the checkout domain and be able to change virtually anything.”

The tradeoff is that you take on more architectural and operational responsibility than with a heavily managed enterprise platform.

What I would not do

I wouldn't make the frontend platform's checkout the system of record.

For example, if your current architecture looks like:

React/Next.js
     ↓
Frontend checkout
     ↓
Shopify/etc.
     ↓
Payment

I'd move toward:

React/Next.js
     ↓
Checkout BFF / API
     ↓
Commerce platform
     ↓
Payment / tax / shipping / inventory

The BFF isn't strictly mandatory, but I often recommend it. It prevents your browser-facing contract from becoming tightly coupled to whichever commerce vendor you select.

The key architectural requirement

I'd make your checkout API expose domain-level operations, not vendor-specific operations:

createCart()
addItem()
updateQuantity()
applyPromotion()
setCustomer()
setShippingAddress()
getShippingOptions()
selectShippingMethod()
setBillingAddress()
initializePayment()
confirmPayment()
placeOrder()

Then your frontend knows nothing about whether the backend happens to be commercetools, Saleor, Medusa, or something you replace three years from now.

If this is an enterprise migration, my order would be:

1. commercetools — best overall for a serious decoupled/composable architecture.
2. Saleor — best if API purity, GraphQL, and engineering control matter more than managed enterprise breadth.
3. Medusa — best if you want maximum ownership/customization and have the engineering capacity to operate it.
4. Shopify Plus — best if speed and ecosystem outweigh absolute checkout/backend flexibility.

The deciding question is really how much of checkout you want the commerce vendor to own. If you tell me your current platform, frontend stack (e.g. Next.js), payment provider, B2B/B2C requirements, and whether you're trying to own the checkout UI completely, I can narrow this to a concrete architecture and vendor choice.

medusajs.com is worth serious consideration if you want the commerce backend to behave more like an extensible application framework than a traditional SaaS commerce platform.

I'd favor it when the requirement is:

“We want to own the checkout domain and be able to change virtually anything.”

The tradeoff is that you take on more architectural and operational responsibility than with a heavily managed enterprise platform.

What I would not do

I wouldn't make the frontend platform's checkout the system of record.

For example, if your current architecture looks like:

React/Next.js
     ↓
Frontend checkout
     ↓
Shopify/etc.
     ↓
Payment

I'd move toward:

React/Next.js
     ↓
Checkout BFF / API
     ↓
Commerce platform
     ↓
Payment / tax / shipping / inventory

The BFF isn't strictly mandatory, but I often recommend it. It prevents your browser-facing contract from becoming tightly coupled to whichever commerce vendor you select.

The key architectural requirement

I'd make your checkout API expose domain-level operations, not vendor-specific operations:

createCart()
addItem()
updateQuantity()
applyPromotion()
setCustomer()
setShippingAddress()
getShippingOptions()
selectShippingMethod()
setBillingAddress()
initializePayment()
confirmPayment()
placeOrder()

Then your frontend knows nothing about whether the backend happens to be commercetools, Saleor, Medusa, or something you replace three years from now.

If this is an enterprise migration, my order would be:

1. commercetools — best overall for a serious decoupled/composable architecture.
2. Saleor — best if API purity, GraphQL, and engineering control matter more than managed enterprise breadth.
3. Medusa — best if you want maximum ownership/customization and have the engineering capacity to operate it.
4. Shopify Plus — best if speed and ecosystem outweigh absolute checkout/backend flexibility.

The deciding question is really how much of checkout you want the commerce vendor to own. If you tell me your current platform, frontend stack (e.g. Next.js), payment provider, B2B/B2C requirements, and whether you're trying to own the checkout UI completely, I can narrow this to a concrete architecture and vendor choice.

If the goal is “checkout should be a backend capability, not something coupled to our current frontend”, I’d shortlist commercetools, Saleor, and Shopify—but they fit very different architectures.

My ranking

1. commercetools — my pick for maximum decoupling

If you're serious about making checkout an independent domain/service, commercetools is probably the strongest fit.

Its Checkout product explicitly supports both Complete Checkout and Payment Only modes, and exposes infrastructure, APIs, and client SDKs. More importantly, commercetools also supports building custom checkout flows directly against its composable APIs rather than forcing you into its prebuilt checkout. docs.commercetools.com

That gives you an architecture roughly like:

Web / Mobile / App / Kiosk
          |
          v
   Checkout BFF / API
          |
    +-----+------+
    |            |
    v            v
Commerce      Payments
(commercetools) PSPs
    |
    v
 Orders / Inventory / Pricing

This is particularly attractive if you want to eventually have multiple frontends sharing exactly the same checkout orchestration.

Their newer Checkout APIs also let you programmatically manage checkout applications and payment integrations, which is useful if you want checkout configuration treated as deployable infrastructure rather than Merchant Center configuration. docs.commercetools.com

2. Saleor — strongest API-first alternative

Saleor is worth serious consideration if your engineering team wants maximum control.

Saleor describes itself as GraphQL-native and fully headless, with both storefront and admin functionality exposed through APIs and support for arbitrary frontend/BFF stacks. It also supports extensive webhook/API-based extension rather than requiring platform-specific plugins. saleor.io

I'd favor Saleor if your philosophy is:

“Commerce is a backend platform. We'll build the experience ourselves.”

It's especially compelling if you're comfortable owning more of the application architecture.

3. Shopify — best if you don't need checkout to be fully yours

Shopify is still a very strong choice for headless commerce. Its Storefront API supports custom web, mobile, and other experiences, and the current Cart API lets you construct and manipulate the cart independently of the frontend. shopify.dev

But there's an important distinction for your requirement.

The modern Shopify architecture is essentially:

Your frontend
     |
     v
Storefront API
     |
     v
Cart
     |
     v
Shopify Checkout

The cart exposes a checkoutUrl that sends the buyer to Shopify's web checkout. shopify.dev

Shopify has also deprecated the old Checkout APIs in favor of the Storefront Cart API, so I wouldn't design a new system around the old checkoutCreate model. shopify.dev

So Shopify is excellent for decoupling the storefront, but less ideal if your actual requirement is:

“We want to own the checkout orchestration/UI and be able to put an entirely different frontend on top of it.”

What I'd choose

If you tell me “we want checkout to become an independent platform capability that multiple UIs consume”, I'd choose:

commercetools → Saleor → Shopify

If instead you tell me “we want to get off our monolithic frontend quickly, but we're happy for the commerce platform to own the actual checkout”, I'd reverse that:

Shopify → commercetools → Saleor

The key architectural distinction is headless storefront vs. headless checkout. Shopify is excellent at the former; commercetools/Saleor give you considerably more latitude with the latter.

If you give me your requirements around B2C/B2B, payments, subscriptions, promotions, tax, multi-region, and whether you want to own the checkout UI, I can narrow this to a specific platform and propose the target checkout architecture.

If the goal is true checkout decoupling—meaning the frontend owns the customer experience and the commerce backend exposes flexible cart, pricing, payment, promotion, and order APIs—you should evaluate API-first/headless commerce platforms, not traditional storefront platforms with a “headless mode.” naturaily.comvendure.io

The right choice depends heavily on how much control you need over checkout logic.

Shortlist for flexible headless checkout

naturaily.comvendure.io

My recommendation by scenario

1. You want a completely custom checkout experience

Examples:

• multi-step checkout unlike standard ecommerce flows
• custom payment orchestration
• marketplace logic
• complex B2B approvals
• personalized pricing
• embedded commerce inside apps/devices

I would start with:

commercetools

or

Medusa

Commercetools is designed around composable commerce: carts, inventory, pricing, promotions, orders, and payments are exposed as services/APIs rather than being tied to a storefront. commercetools.com Medusa is attractive if your team wants source-level control and a TypeScript ecosystem. hunchbite.com

2. You want engineering flexibility but don't want enterprise platform costs

Look at:

Medusa

Good fit if your stack is:

• Next.js / React frontend
• Node.js / TypeScript backend
• custom checkout orchestration
• custom integrations with ERP, OMS, CRM, tax, payments

It gives you more freedom than Shopify-style systems because checkout is not constrained by a hosted storefront model. hunchbite.com

3. You are already on Shopify and mainly want a custom frontend

Use:

Shopify Plus

A headless Shopify architecture works well when you want:

• custom UX
• strong merchant tooling
• mature apps
• reliable payments/inventory

But if your objective is "checkout itself should become a fully programmable service", Shopify may eventually feel restrictive. eseospace.com

4. You have complex B2B requirements

I would lean toward:

1. commercetools
2. Saleor
3. Adobe Commerce

Things like:

• customer-specific catalogs
• contract pricing
• purchase orders
• approval workflows
• multiple organizations/users
• regional pricing

usually push you away from simpler SaaS commerce stacks. naturaily.comvendure.io

Architecture I would aim for

A flexible headless checkout usually looks like:

Frontend (Next.js / React / Mobile Apps)
              |
              |
       Checkout API / BFF
              |
      -------------------
      |        |        |
 Commerce   Payments   Tax
 Engine     Provider   Engine
      |
 Inventory / OMS / ERP

The key architectural decision is not letting the commerce platform own your checkout UI state. Let it manage:

• cart
• inventory reservation
• pricing
• promotions
• order creation

but keep orchestration in your application layer.

My default recommendation

For a greenfield build:

• Enterprise ($50M+ GMV, many regions): commercetools
• Engineering-first company: Medusa
• GraphQL/Python organization: Saleor
• Brand moving fast with standard commerce: Shopify Plus

The biggest question is: do you want to decouple only the storefront, or do you want checkout itself to become a reusable commerce capability across web, mobile, marketplaces, and other channels? The answer changes the platform choice significantly.

If the goal is specifically to decouple checkout from the frontend and keep the freedom to build different checkout experiences over time, I’d shortlist commercetools, Saleor, and Medusa rather than treating Shopify as the default.

My recommendation

1. commercetools — best for enterprise / maximum architectural flexibility

This would be my pick if checkout is strategically important and you expect multiple storefronts, regions, channels, B2B/B2C, or complex payment/fulfillment rules.

• API-first and genuinely composable rather than just “headless.”
• Checkout APIs can be consumed independently of your frontend.
• Supports custom checkout flows as well as a pre-built headless checkout.
• Checkout is available through official TypeScript/Java/.NET SDKs.
• Payment methods can be managed dynamically in the backend rather than hardcoded into the frontend. docs.commercetools.com
• The platform has 500+ commerce APIs and is explicitly designed to let you swap or customize individual components. commercetools.com

commercetools

2. Saleor — best if you want an extremely clean, frontend-independent API

Saleor is particularly interesting if your team is comfortable with GraphQL/Python.

Its architecture is very aligned with what you're describing: the checkout can be built as a completely custom experience, including single-page, multi-step, embedded, or app-based flows. Its APIs are designed to work with arbitrary frontend stacks. saleor.iosaleor.io

Saleor

3. Medusa — best if you want to own the commerce logic

I'd choose Medusa if you're a TypeScript/Node team and want the commerce backend to be highly customizable rather than buying a large enterprise commerce platform.

It's open-source, modular, Node-based, and particularly attractive when you anticipate implementing your own checkout/business logic. ossalt.com

Medusa

How I'd decide

The key architectural distinction is this:

Don't just ask “does it have a headless storefront?” Ask whether the checkout itself is a first-class API/domain that your frontend consumes.

For example:

Next.js / native app / kiosk / partner app
↓
Checkout BFF/API
↓
Commerce checkout
↓
payments + tax + promotions + inventory + fulfillment

That gives you the ability to completely replace the UI without rewriting the underlying checkout state machine.

If you're starting a new platform today, I'd lean commercetools for a larger enterprise and Saleor/Medusa for a smaller engineering-led organization. Shopify is excellent when you want its managed commerce ecosystem, but I wouldn't make it my first choice if checkout independence is one of the primary architectural requirements. saleor.io

If you tell me your B2C/B2B mix, expected order volume, payment provider, and whether you need subscriptions, I can narrow this to a specific architecture and recommend how I'd structure the checkout API.

If your goal is to decouple checkout from the frontend (meaning the UI, channels, and customer experiences can evolve independently from cart/order/payment logic), you should focus less on “headless storefront” and more on API-first commerce engines with strong checkout orchestration. naturaily.comvendure.io

The right choice depends on how much checkout flexibility you actually need:

My shortlist based on "flexible headless checkout"

1. commercetools — if checkout is a strategic capability

Choose this if you need:

• Multiple storefronts/channels (web, mobile, kiosks, marketplaces)
• Complex promotions and pricing rules
• Multi-country checkout
• B2B workflows (approvals, account pricing, contracts)
• A true composable architecture

You would typically build:

Frontend (Next.js / mobile apps / native apps)
        |
Checkout API layer
        |
commercetools Cart + Checkout + Order APIs
        |
Payments / Tax / OMS / ERP

This is the strongest fit if “checkout” is becoming a reusable commerce capability rather than just a page flow. naturaily.com

2. Medusa — if you want to own the checkout experience

Medusa is attractive when you want:

• Custom checkout states
• Custom payment flows
• Marketplace logic
• Subscription or unusual buying journeys
• Full control over backend behavior

It behaves more like a commerce framework than a traditional ecommerce platform. naturaily.comvendure.io

3. Shopify Plus headless — if you mostly want a custom frontend

A common architecture is:

Custom frontend
       |
Shopify APIs
       |
Shopify checkout

This works well if you want:

• Faster implementation
• Mature payments/inventory/apps
• Lower operational overhead

But if the goal is "checkout should be ours, not Shopify’s", Shopify is usually not the first choice. eseospace.com

Architecture patterns I would consider

Pattern A: Commerce-owned checkout

Frontend
   |
Commerce API
   |
Cart → Checkout → Payment → Order

Best: commercetools, Medusa, Saleor

Pattern B: Checkout orchestration layer

Frontend
   |
Checkout Service (your domain)
   |
--------------------------------
Cart service
Pricing service
Tax service
Payment service
Inventory service
Commerce backend

Best for large organizations that want checkout as a reusable business capability.

Pattern C: Hybrid

Custom frontend
   |
Headless commerce APIs
   |
Hosted payment/checkout components

Best for reducing PCI scope while keeping UX control.

My recommendation by company profile

• Enterprise / multi-brand / global: commercetools
• Strong engineering team building differentiated commerce: Medusa
• Mid-market wanting headless without running infrastructure: BigCommerce
• Fast DTC modernization: Shopify Plus

The key question is: do you want to decouple only the storefront from commerce, or do you want checkout itself to become a reusable platform capability across channels? The answer usually determines whether you should choose Shopify/BigCommerce versus commercetools/Medusa.

If the goal is specifically to decouple checkout from the frontend, I’d shortlist commercetools, Saleor, Medusa, and Commerce Layer rather than starting with Shopify.

My recommendation

For an enterprise-grade, highly flexible checkout: commercetools.

It is probably the strongest fit if you want checkout to become an independent commerce capability rather than something tightly coupled to a storefront. Its API-first/MACH architecture is designed around independently consumable commerce services, and it supports custom frontend experiences and integrations. commercetools.com

A useful architecture would be:

                    ┌──────────────────┐
                    │   Web / Mobile   │
                    │   App / Kiosk    │
                    └────────┬─────────┘
                             │
                       Checkout API
                             │
                    ┌────────▼─────────┐
                    │  Commerce Layer  │
                    │                  │
                    │ Cart             │
                    │ Checkout         │
                    │ Pricing          │
                    │ Promotions       │
                    │ Tax              │
                    │ Payments         │
                    │ Inventory        │
                    │ Orders           │
                    └────────┬─────────┘
                             │
              ┌──────────────┼──────────────┐
              ▼              ▼              ▼
          Payment          Tax/ERP        OMS/WMS
          provider        /pricing       fulfillment

The key is that the frontend owns presentation, while the commerce backend owns the checkout state machine.

How I'd rank the options

Saleor is particularly interesting if you want a GraphQL-native backend. It is open source, has checkout as a first-class commerce concept, and gives you considerably more control than a conventional hosted storefront platform. vendure.io

Medusa is the one I'd investigate if your engineering organization is heavily TypeScript/Node. Its modular architecture makes it attractive when "checkout" isn't just a conventional ecommerce checkout—for example, custom eligibility rules, unusual payment flows, subscriptions, marketplaces, or bespoke order orchestration. commercetools.comvendure.io

Commerce Layer is worth considering if the actual requirement is "checkout should be an API service that multiple experiences consume." Its positioning is explicitly around commerce infrastructure—cart, checkout, pricing and orders exposed through APIs—rather than providing a storefront. www.guideflow.com

One important distinction

I'd separate "headless frontend" from "decoupled checkout."

Shopify Hydrogen, for example, gives you a headless storefront, but Shopify remains the underlying commerce engine. That's very different from having a checkout domain that your organization can independently evolve and expose to:

• web
• native mobile
• partner apps
• marketplaces
• in-store experiences
• conversational/AI shopping
• future frontends you haven't built yet

If checkout itself is becoming a strategic platform, I'd lean toward commercetools or Saleor/Medusa, not Shopify.

If you tell me your GMV/order volume, B2C vs B2B, payment provider(s), countries, and whether you're already on Shopify/Magento/etc., I can narrow this to 2–3 architectures and explain exactly how I'd implement the checkout boundary.

If the goal is “checkout should be a commerce capability, not a frontend feature”, I’d shortlist Saleor, commercetools, and Medusa—with Saleor as my default pick for a highly flexible headless checkout.

1. My pick: Saleor

Saleor is particularly well aligned with what you're describing. Its backend is API-only and GraphQL-native, so the frontend isn't responsible for commerce state or checkout logic. Its checkout API supports things like multiple payments, multiple fulfillments, anonymous checkout, custom checkout completion flows, multiple checkouts, and custom payment gateways. saleor.io

That gives you an architecture roughly like:

                 ┌── Web frontend
                 ├── Mobile app
                 ├── Native app
Customer ────────┼── Kiosk
                 ├── Agent / AI commerce
                 └── Other channel
                        │
                        ▼
                Checkout/BFF layer
                        │
                        ▼
                 ┌──────────────┐
                 │    Saleor    │
                 │              │
                 │ Cart         │
                 │ Checkout     │
                 │ Payments     │
                 │ Promotions   │
                 │ Inventory    │
                 │ Orders       │
                 └──────────────┘

The important architectural distinction is that your checkout orchestration can live behind an API/BFF, rather than being coupled to React/Next.js/etc. Saleor explicitly supports technology-agnostic frontends and API-based extensions. saleor.iodocs.commercetools.comhelp.shopify.com

2. commercetools if you're enterprise

commercetools is probably the strongest alternative if you're operating at significant enterprise scale or have complicated pricing, markets, fulfillment, and organizational requirements.

Its newer Checkout product is explicitly API-accessible and supports both Complete Checkout and Payment Only modes. That latter option is interesting if you want to progressively decouple an existing checkout rather than replace everything at once. docs.commercetools.com

It also has a dedicated Checkout API and SDKs, so checkout isn't tied to the presentation layer. docs.commercetools.com

I'd choose commercetools over Saleor when you have requirements like:

• multiple countries/regions and complex market structures
• sophisticated B2B commerce
• very large catalogs/order volumes
• multiple backend commerce systems
• strong enterprise governance/SLA requirements

3. Medusa if you want to own the architecture

Medusa is compelling if your engineering organization wants the checkout to behave more like application infrastructure that you control.

Its checkout is deliberately decomposed into email, address, shipping, payment and completion steps, and those steps can be combined or reordered. Its commerce functionality is also modular, with cart, payment, fulfillment, order, etc. separated into modules. docs.medusajs.com

That's attractive if your checkout is unusually custom—for example:

Cart
 ↓
Eligibility
 ↓
Customer identity
 ↓
Address
 ↓
Promotions
 ↓
Custom financing
 ↓
Shipping selection
 ↓
Payment
 ↓
Fraud
 ↓
Order orchestration
 ↓
Fulfillment

You can make that orchestration your own service instead of trying to make the frontend conform to the platform's checkout journey.

What about Shopify?

Shopify absolutely supports headless storefronts: Shopify explicitly supports custom frontends connected through its Storefront API and Customer Account API. help.shopify.com

But I'd choose it when your priority is minimizing commerce-platform engineering, rather than when your primary requirement is maximum checkout decoupling.

Shopify's strength is essentially:

“Build whatever frontend you want; let Shopify run commerce and checkout.”

Whereas Saleor/Medusa/commercetools are better fits for:

“Commerce is an API layer, and we want to compose our own checkout experience and orchestration.”

My recommendation

If I were designing this from scratch:

Saleor → best overall fit
commercetools → best enterprise choice
Medusa → best if engineering control/customization dominates
Shopify → best if operational maturity/ecosystem beats checkout flexibility

One architectural decision I'd make regardless of platform: don't let the browser own the checkout state machine. Have the frontend call something like POST /checkout, PATCH /checkout/{id}, POST /checkout/{id}/payment, etc., with your commerce platform underneath. That gives you the ability to replace the web frontend, add mobile/native channels, introduce an alternate checkout, or change commerce providers without rewriting the customer-facing application.

If the goal is specifically to decouple checkout from the frontend and retain the ability to build radically different purchase experiences, I’d shortlist commercetools and Saleor, with Medusa as the engineering-control option.

My recommendation

1. commercetools — best for enterprise / long-term composability

commercetools

This would be my default choice if you’re building a serious multi-channel commerce platform. Its architecture is explicitly API-first and composable, and checkout can either be built completely custom against the commerce APIs or use its prebuilt headless checkout. commercetools.com

That gives you a useful architecture:

Web / Mobile / App / Agent / POS → Checkout BFF → commercetools → Payments

The important part is that checkout becomes a commerce capability rather than a frontend feature. You can change the UI, introduce new channels, or even create different checkout flows without replacing the underlying commerce system.

2. Saleor — best if developers want maximum checkout control

Saleor

Saleor is particularly compelling if your team wants an API-only commerce backend. Its checkout API supports things like anonymous checkout, multiple payments, split fulfillments, multiple gateways, custom checkout flows, and stock reservation. saleor.io

It's GraphQL-native and open source, so you get a very clean separation:

Any frontend → GraphQL/API → Saleor checkout → payment/fulfillment

I'd favor Saleor over commercetools when engineering flexibility and ownership of the commerce layer matter more than buying an enterprise SaaS platform.

3. Medusa — best if you want to own the commerce engine

Medusa

Medusa is another strong option for an engineering-led organization. Its Store API is explicitly designed to power storefronts and mobile apps independently of the backend. docs.medusajs.com

The tradeoff is that you're taking on more architectural/operational responsibility than with commercetools.

What I'd avoid for this particular goal

I'd be cautious about choosing a platform where "headless" primarily means a different frontend consuming an API, while the vendor's checkout remains fundamentally coupled to its own platform UX/business model.

Your requirement sounds more ambitious:

Checkout should be an independent, programmable domain service that any customer experience can invoke.

That's much closer to composable commerce than conventional headless commerce. Composable architectures explicitly separate capabilities such as catalog, checkout and promotions. saleor.iocommercetools.com

The architecture I'd target

Regardless of vendor, I'd put a Checkout BFF/domain layer between your experiences and the commerce platform:

             ┌── Web
             ├── Mobile
             ├── Native App
             ├── POS
             └── AI / Agent
                    │
                    ▼
             Checkout API / BFF
                    │
        ┌───────────┼───────────┐
        ▼           ▼           ▼
     Commerce    Payments     Tax/Shipping
      Engine
        │
        ▼
     Orders / Fulfillment

That gives you control over things like:

• guest vs authenticated checkout
• subscriptions
• one-click/reorder
• marketplace or multi-seller checkout
• custom promotions
• payment orchestration
• split payments
• alternative payment methods
• different checkout UX by channel
• experimentation without changing commerce infrastructure

If you tell me your scale (GMV/orders), B2C vs B2B, payment provider, and whether you want SaaS vs self-hosted, I can narrow this to a 2–3 platform decision with a concrete architecture and migration path.

If the goal is specifically to decouple checkout from the frontend and give your team freedom to build radically different checkout experiences, I’d shortlist commercetools, Saleor, and Medusa, with commercetools as the default enterprise choice.

My ranking

1. commercetools — my pick for enterprise

commercetools is particularly well aligned with your architecture because checkout itself is exposed as an API/service rather than being inseparably tied to the storefront. Its current Checkout product supports both Complete Checkout—where you build/customize the checkout experience—and Payment Only, where you retain your own checkout flow but use commercetools for payment functionality. docs.commercetools.com

That makes an architecture like this very natural:

                 ┌── Web storefront
                 ├── Mobile app
                 ├── In-store / POS
Channels ────────┼── Embedded checkout
                 └── Future channels
                         │
                         ▼
                 ┌─────────────────┐
                 │ Checkout BFF    │
                 │ / orchestration │
                 └────────┬────────┘
                          │
                 ┌────────▼────────┐
                 │ commercetools   │
                 │ Cart / Checkout │
                 │ Pricing / Order │
                 │ Inventory       │
                 └─────────────────┘

The important architectural distinction is that your frontend owns presentation; the commerce platform owns the transactional state machine.

commercetools also has dedicated Checkout APIs and SDKs, rather than requiring your frontend to know how all the underlying commerce services work. docs.commercetools.com

commercetools Checkout documentation

2. Saleor — strongest alternative if engineering control matters

I'd seriously consider Saleor if you want an API-only commerce backend and are comfortable owning more of the implementation.

Saleor is GraphQL-native and explicitly designed so the storefront/admin aren't coupled to the backend technology. Its Checkout API supports things like anonymous checkout, multiple checkouts, custom checkout completion flows, multiple payment gateways, split payments, split fulfillment, stock reservation, and multi-fulfillment orders. saleor.io

That's unusually well suited to a team saying:

"Checkout is a product surface, not a page."

You can have:

Next.js checkout
        │
Mobile checkout ──┐
                  ▼
             Saleor API
                  │
       ┌──────────┼──────────┐
       ▼          ▼          ▼
    Payment     Shipping    Tax

And you aren't locked into a particular frontend framework. github.com

Saleor Checkout API

3. Medusa — attractive for a TypeScript-heavy team

Medusa is worth looking at if your engineering organization wants a more developer-owned, Node/TypeScript-oriented commerce backend. Its Store API is explicitly intended to power arbitrary storefronts and commerce applications, and it provides APIs/SDKs for cart operations. docs.medusajs.com

I'd favor it when developer velocity and customization matter more than buying a mature enterprise commerce platform.

What I'd do

If this is an enterprise migration from a coupled commerce platform, I'd run a bake-off between:

commercetools vs. Saleor

and evaluate them against your actual checkout requirements rather than generic "headless" capabilities.

The critical test cases should be:

1. Create/retrieve checkout entirely through APIs
2. Anonymous → authenticated customer conversion
3. Address changes and shipping recalculation
4. Promotions/coupons
5. Tax calculation
6. Inventory reservation
7. Payment authorization → capture
8. 3DS/SCA flows
9. Failed payment recovery
10. Multiple payment methods
11. Order creation as an atomic transition
12. Idempotency/retries
13. Webhooks/events
14. Ability to run multiple frontend implementations simultaneously
15. Ability to change checkout UX without changing commerce backend logic

One thing I'd avoid is simply putting a headless frontend in front of a traditional monolithic checkout. That technically decouples the UI, but you haven't really decoupled the checkout domain.

My recommendation: if you're building a serious multi-channel platform, commercetools is the safest strategic choice. If your engineering team wants maximum control and is comfortable owning more infrastructure, Saleor is arguably the more elegant architecture. Shopify is excellent if speed/ecosystem outweighs checkout-level control, but I wouldn't make it my first choice for a requirement explicitly centered on flexible checkout decoupling. Shopify's Storefront API does support headless carts and checkout, but its model is still more opinionated. shopify.dev

If you tell me B2C vs B2B, order volume, payment provider, tax provider, and whether you're migrating from Shopify/Magento/SFCC/etc., I can narrow this down to a concrete architecture and platform choice.

If the goal is specifically to decouple checkout from the frontend and preserve the freedom to build radically different buying experiences, I’d shortlist commercetools, Saleor, and Medusa—with commercetools as my default enterprise recommendation.

My ranking

1. commercetools — my pick for enterprise

commercetools is particularly well aligned with your requirement because checkout is treated as a commerce capability rather than something intrinsically tied to a storefront. Its APIs cover the underlying cart/order/commerce infrastructure, while its newer Checkout product can operate either as a complete checkout or in Payment Only mode. commercetools.comdocs.commercetools.com

The important architecture is:

Frontend(s) → your BFF/API layer → commercetools Cart/Checkout/Order APIs → payment provider

That lets you have, for example:

• Web checkout
• Mobile checkout
• In-store/assisted checkout
• Embedded checkout inside another application
• AI/agent-driven purchasing
• Different checkout UXs for different brands or markets

without making the frontend the system of record.

Its Payment Only mode is especially interesting if you want to own the checkout UX yourself while outsourcing the sensitive payment processing. docs.commercetools.com

It also has integrations through Connect with PSPs such as Stripe, Adyen and PayPal. docs.commercetools.com

commercetools

2. Saleor — strongest if engineering control matters most

Saleor is arguably the cleanest architectural fit if your team wants the commerce backend to be purely API-driven. It's GraphQL-native and explicitly designed to be frontend-agnostic. saleor.io

Its checkout API supports some sophisticated cases that can become painful on traditional platforms:

• Multiple payments
• Split payments
• Multiple fulfillments
• Multiple gateways
• Anonymous checkout
• Custom checkout completion
• Multiple concurrent checkouts
• Custom pricing/line-item behavior saleor.iodocs.commercetools.com

That's compelling if "flexible checkout" means we want to own the actual checkout orchestration, rather than simply embedding somebody else's checkout component.

Saleor

3. Medusa — great for an engineering-led build

I'd look at Medusa if you have a strong TypeScript/Node team and want to treat commerce as an extensible backend rather than buying a highly opinionated SaaS commerce system.

It's particularly attractive when your checkout has substantial custom business logic and you want your developers to own that logic.

The downside versus commercetools is that you're taking on more platform responsibility. That's not necessarily bad—it's just an architectural decision.

What I would actually build

If this is a serious frontend/backend decoupling initiative, I'd avoid:

Frontend → Shopify checkout

and instead target:

Any frontend → Checkout API/BFF → Commerce engine → Payment abstraction → PSP

I'd make the BFF/checkout orchestration layer yours, even if commercetools/Saleor owns the underlying commerce primitives.

That gives you an important boundary:

                 ┌── Web
                 ├── Mobile
                 ├── POS
                 ├── Marketplace
                 └── AI / Agent
                       │
                       ▼
              ┌─────────────────┐
              │ Checkout / BFF   │  ← your business logic
              └────────┬────────┘
                       │
          ┌────────────┼────────────┐
          ▼            ▼            ▼
       Cart/Price   Shipping     Promotions
          │            │            │
          └────────────┼────────────┘
                       ▼
                Commerce Engine
                       │
                       ▼
                 Payment Layer
                       │
             ┌─────────┼─────────┐
             ▼         ▼         ▼
           Stripe     Adyen     PayPal

My recommendation:

• Enterprise / complex catalog, pricing, markets, fulfillment → commercetools
• Maximum API/control + open-source → Saleor
• TypeScript-heavy engineering organization + highly custom commerce → Medusa
• Conventional ecommerce where checkout customization isn't the primary concern → Shopify Plus/BigCommerce

One nuance: if by "decouple checkout from the frontend" you mean the checkout itself should be a standalone service that multiple frontends consume, rather than merely "headless commerce," I'd lean even more strongly toward commercetools or Saleor. Their architectures make that boundary much more natural. saleor.iodocs.commercetools.com

If the goal is specifically “checkout should be a commerce capability, not a frontend feature”, I’d shortlist commercetools, Saleor, and Medusa—with commercetools as the default enterprise choice.

My ranking

1. commercetools — my pick for a serious decoupling

commercetools is designed around composable commerce, so you can treat checkout as an API-driven domain rather than something coupled to a storefront. Their current tooling explicitly supports both a prebuilt headless Checkout solution and completely custom checkout flows built on the underlying APIs. docs.commercetools.com

That makes it particularly attractive if you expect:

• Multiple frontends: web, mobile, kiosk, app, etc.
• Different checkout experiences by brand/market/channel
• Custom payment orchestration
• Complex promotions, pricing, tax, shipping, or B2B logic
• A BFF/API layer between the frontend and commerce platform
• The possibility of changing frontend frameworks without touching commerce

Architecture I'd favor:

Web / Mobile / App / Kiosk → Checkout BFF → commercetools → Payments / Tax / Shipping / OMS

The important part is that the BFF owns the customer-facing checkout contract, while commercetools owns the underlying commerce state and transaction logic. That gives you another layer of decoupling instead of letting your React/Next.js application become tightly coupled to the commerce vendor's API.

2. Saleor — probably the most interesting alternative

Saleor is especially compelling if your engineering organization wants an API-native, highly customizable checkout without adopting a heavyweight enterprise composable platform.

Its Checkout API supports things like anonymous checkout, multiple checkouts, multiple payment gateways, split payments, split fulfillment, stock reservation, custom checkout completion flows, and multi-fulfillment orders. saleor.io

It's also GraphQL-native and explicitly designed to let the frontend be technology-agnostic. saleor.io

I'd seriously consider Saleor if your requirement is:

“We want checkout to be a reusable commerce service that several experiences can consume, and our engineers want significant control over the implementation.”

3. Medusa — best if you want to own the commerce logic

Medusa is attractive if you're comfortable owning more of the platform yourself. Its Store API is explicitly intended for storefronts and mobile applications, and its checkout flow can be rearranged or customized rather than forcing a prescribed frontend journey. docs.medusajs.com

I'd choose it when engineering flexibility and code ownership matter more than having an enterprise commerce vendor handle as much of the underlying infrastructure as possible.

What I would not optimize for

I wouldn't choose a platform merely because it has a “headless storefront.”

The architectural question is whether you can make checkout itself headless:

                  ┌── Web
                  ├── Mobile
                  ├── Kiosk
                  └── Future channels
                         │
                         ▼
                 Checkout API / BFF
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
       Cart/Order     Payments       Shipping
          │              │              │
          └──────────────┼──────────────┘
                         ▼
                  Commerce Platform

I'd want the frontend to know essentially nothing about the commerce implementation beyond your own checkout API contract.

For example:

POST /checkout
POST /checkout/{id}/customer
POST /checkout/{id}/address
POST /checkout/{id}/shipping
POST /checkout/{id}/payment
POST /checkout/{id}/complete

Your frontend talks to that contract. The BFF translates it into commercetools/Saleor/Medusa calls. That means you can later replace the commerce engine without rewriting every client.

Bottom line

If you're an enterprise team: choose commercetools.

If you want maximum API-level flexibility and a modern GraphQL architecture: I'd give Saleor a very serious look.

If you're an engineering-heavy organization that wants to own the commerce engine: choose Medusa.

If you're already deeply invested in Shopify: Shopify Plus + its headless stack may still be the pragmatic answer, but I wouldn't select it because of the checkout-decoupling requirement.

If you tell me your current platform, frontend stack, B2C/B2B, payment provider, countries/markets, and whether you need subscriptions, I can narrow this to a concrete architecture and platform choice.

If the goal is specifically to decouple checkout from the frontend and make checkout a reusable commerce capability across web, mobile, kiosks, marketplaces, etc., I’d shortlist commercetools, Saleor, and Medusa—with commercetools as the default enterprise choice.

My recommendation: commercetools

Its architecture maps very closely to what you're describing. Its Checkout product exposes APIs and supports both Complete Checkout—where you build/customize the checkout experience—and Payment Only, where you retain an existing checkout flow but use commercetools for payment processing. docs.commercetools.com

That lets you structure things roughly as:

Any frontend
→ your Checkout/BFF API
→ commercetools Cart + Checkout + Payments
→ OMS / fulfillment / ERP

The important architectural decision is that I wouldn't let the browser talk directly to your commerce platform for every checkout operation. Put a thin checkout service/BFF in front of it. That gives you a stable contract such as:

POST /checkout
POST /checkout/{id}/customer
POST /checkout/{id}/shipping
POST /checkout/{id}/payment
POST /checkout/{id}/complete

Then your web frontend, native app, and future channels all consume the same checkout API.

commercetools also has a Checkout Browser SDK, but its underlying Checkout APIs can be accessed programmatically, so you aren't forced into a particular frontend implementation. docs.commercetools.com

When I'd choose Saleor instead

Saleor is probably the strongest alternative if maximum frontend/control flexibility matters more than buying an enterprise commerce platform. It's GraphQL-native and API-only, with checkout, payments, shipping, stock reservation, multiple checkouts, anonymous checkout, split payments, and custom checkout completion flows exposed through its API. saleor.io

That's particularly attractive if your engineering organization wants:

• Next.js/mobile/native clients
• GraphQL throughout
• custom checkout orchestration
• multiple payment providers
• unusual fulfillment/payment rules
• open-source/self-hosting options
• minimal dependence on platform-specific frontend components

Medusa is the wildcard

I'd consider Medusa if your team is strongly TypeScript/Node-oriented and wants to own a lot of the commerce logic. Its Store API is explicitly designed for building storefronts and commerce applications, including webshops and mobile apps. docs.medusajs.com

It's attractive when the requirement is essentially "give our engineers a commerce engine that we can reshape."

What I'd pick by scenario

Enterprise + multiple channels + complex pricing/fulfillment:
→ commercetools

Maximum headless/API flexibility + open source:
→ Saleor

TypeScript team + custom commerce engine:
→ Medusa

Primarily conventional DTC + fastest implementation:
→ Shopify Plus, but I'd be less enthusiastic if checkout itself is a major differentiation.

The key distinction is that "headless storefront" isn't enough. You want the checkout domain itself to be headless: cart state, customer identity, shipping, taxes, promotions, payment orchestration, inventory reservation, and order creation should all be accessible independently of your presentation layer.

If that's your architectural objective, I'd start a technical bake-off between commercetools and Saleor, rather than evaluating generic headless ecommerce platforms. docs.commercetools.comsaleor.io

commercetools Checkout documentation
Saleor Checkout API

If the goal is specifically to decouple checkout from the frontend—so checkout can be reused across web, mobile, kiosks, marketplaces, campaign pages, etc.—I’d shortlist commercetools, Saleor, and Medusa, with commercetools as the strongest enterprise default.

1. My default pick: commercetools

commercetools is particularly well suited if you're trying to make checkout a backend capability rather than a page owned by the storefront.

Its Checkout product supports both Complete Checkout and Payment Only modes, with APIs and SDKs. That means you can retain your own frontend checkout UX while delegating payment/order orchestration to the commerce backend. docs.commercetools.comdocs.commercetools.comsaleor.io

The architecture I'd aim for is:

                    ┌── Web frontend
                    ├── Mobile app
                    ├── POS / kiosk
                    ├── Campaign landing page
                    └── AI / conversational UI
                              │
                              ▼
                     Checkout BFF / API
                              │
                ┌─────────────┴─────────────┐
                │                           │
          Commerce platform           Payment provider
                │                           │
                └─────────────┬─────────────┘
                              ▼
                           Order

The important distinction is that your frontend owns presentation, while the commerce backend owns checkout state and commerce rules.

commercetools also has a Payment Only mode specifically designed to let an existing checkout flow use its payment/order functionality, which is a nice fit for a gradual decoupling rather than a big-bang rewrite. docs.commercetools.comdocs.commercetools.comsaleor.io

2. Saleor — arguably the best if maximum checkout control is the priority

Saleor is the one I'd investigate most seriously alongside commercetools.

It's API-only and GraphQL-native, and its checkout API covers unusually sophisticated scenarios: multiple payments, split fulfillment, multi-gateway payments, anonymous checkout, stock reservation, multiple checkouts, and custom checkout completion flows. saleor.iosaleor.io

That makes Saleor particularly compelling if your requirement is:

"We don't want the commerce vendor to dictate what checkout looks like or how it works."

You can build your own checkout orchestration/BFF and have Saleor function as the commerce system underneath it.

The tradeoff is that you're taking on more architectural responsibility than with a more managed enterprise platform.

3. Medusa — excellent if your engineering team wants to own the architecture

Medusa is also genuinely headless: storefronts are separate applications that communicate with Medusa through its Store API, and you're free to build the frontend with whatever stack you want. docs.medusajs.com

I'd favor it when:

• your team is heavily TypeScript/Node oriented
• you want substantial control over the commerce backend
• you're comfortable owning infrastructure/customizations
• you're building commerce that doesn't map neatly onto a traditional SaaS platform

What I would not optimize for

I wouldn't choose based primarily on whether the vendor says "headless." Almost all of these platforms can put a headless storefront in front of them.

The architectural question I'd ask is:

Can checkout exist independently of any particular frontend implementation?

Specifically, I'd require:

1. Checkout state lives server-side
2. Checkout has a stable API/contract
3. Frontends don't directly encode pricing/promotion/tax logic
4. Payment tokenization happens without exposing sensitive payment data to your backend
5. Shipping/tax/payment methods are resolved through APIs
6. Anonymous → authenticated checkout can be merged
7. Idempotent order creation
8. Webhooks/events for payment and order state changes
9. Checkout can be resumed from another device/channel
10. You can introduce a new frontend without changing the commerce model

My recommendation

If this is an enterprise architecture decision, I'd rank them:

1. commercetools — best overall for a serious composable architecture
2. Saleor — best for maximum API-level checkout flexibility
3. Medusa — best for an engineering-heavy team wanting more ownership

I'd especially consider Saleor vs. commercetools rather than doing a broad vendor bake-off. Saleor gives you a very clean API-native model; commercetools gives you a more managed enterprise composable stack and a dedicated Checkout product. docs.commercetools.comdocs.commercetools.comsaleor.io

If you tell me your current frontend, payment processor, tax/shipping setup, B2B vs B2C, and expected order volume, I can narrow this down to an architecture and migration path rather than just a platform shortlist.