ChatGPT answers, unedited

If the goal is specifically “decouple checkout from the frontend so we can own the UX and evolve it independently,” I’d shortlist commercetools and Shopify, with the choice depending on how much checkout logic you want to own.

My recommendation

If checkout itself is a strategic product capability, I'd use commercetools.

Its current Checkout product is explicitly designed to separate checkout from the experience layer. It supports both Complete Checkout—where you build/customize the checkout experience—and Payment Only, where you retain an existing checkout flow but use its payment functionality. It also exposes APIs and SDKs, including TypeScript, Java, and .NET. commercetools Documentation commercetools Documentation

That gives you an architecture like:

                    ┌──────────────────────┐
                    │   Web / Mobile / App │
                    └──────────┬───────────┘
                               │
                         Your Checkout API
                               │
                    ┌──────────▼───────────┐
                    │   Checkout Service   │
                    │                      │
                    │ address              │
                    │ shipping             │
                    │ promotions           │
                    │ tax                  │
                    │ payments             │
                    │ order creation       │
                    └──────────┬───────────┘
                               │
                    ┌──────────▼───────────┐
                    │    commercetools     │
                    │ Commerce + Checkout  │
                    └──────────────────────┘

That is particularly attractive if you expect checkout to eventually serve multiple frontends, experiments, mobile apps, kiosks, marketplaces, or other channels.

When I'd choose Shopify instead

If you want headless without taking on as much commerce infrastructure, Shopify is compelling. Its Storefront API is explicitly designed for custom storefronts and supports products, carts and checkout, while remaining framework-agnostic—you can use Next.js, Vue, Hydrogen, etc. Shopify Shopify

Shopify's current architecture also supports a Headless channel specifically for self-hosted/custom storefronts. Shopify

The tradeoff is that you're still working within Shopify's checkout/payment/order model. So if your requirement is “we want to completely own the checkout domain”, I'd lean commercetools; if it's “we want our frontend decoupled from Shopify while letting Shopify handle the hard commerce/payment pieces,” I'd lean Shopify.

One important architectural distinction

I would not make the browser talk directly to whichever commerce platform owns checkout for every operation.

Instead:

Frontend
   ↓
Your BFF / Checkout API
   ↓
Commerce platform
   ↓
PSP / tax / fraud / shipping

That gives you a stable checkout contract such as:

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

Then you can change the frontend—or even replace the commerce platform—without rewriting the checkout experience.

So, for a greenfield enterprise architecture: commercetools would be my first platform to evaluate; Shopify would be my comparison point if speed-to-market and ecosystem breadth matter more than maximum checkout composability. Commercetools also explicitly supports building custom checkout flows directly from its composable APIs, rather than forcing you into its prebuilt Checkout experience. commercetools Documentation

If you tell me your current stack (e.g. Shopify/Magento/custom), B2C vs B2B, payment provider, and whether you need subscriptions, promotions, tax, or multi-country, I can narrow this to a concrete architecture and platform shortlist.

If the goal is specifically “checkout should be a commerce service, not a frontend feature”, I’d shortlist commercetools, Saleor, Medusa, and Shopify—but they represent very different levels of control.

My architectural take

If checkout is strategically important and you expect unusual flows, I'd start with Saleor or commercetools.

commercetools is particularly interesting if you want checkout to become an independently evolving service. Its Checkout product has a dedicated Checkout API, and the SDKs support it directly; the platform is designed around composable commerce rather than treating headless as primarily a storefront concern. commercetools Documentation commercetools Documentation

Saleor is compelling if you want maximum control without building the entire commerce engine yourself. Its APIs are GraphQL-native, and Saleor explicitly supports decoupling the frontend while extending commerce behavior through APIs/webhooks. Saleor Commerce Saleor Commerce

Medusa makes sense if your team is strongly TypeScript/Node-oriented and wants to own the checkout domain. Its modular architecture is well suited to replacing pieces of the standard checkout rather than fighting a SaaS platform's prescribed flow. PowerGate Software OSSAlt

Shopify is the operationally simpler choice. Its current Storefront API supports custom storefronts, carts and checkout, and Shopify explicitly supports bringing your own frontend/framework. However, there's an important architectural distinction: you're consuming Shopify's checkout infrastructure rather than owning an independently deployable checkout domain. Shopify Shopify

One important Shopify detail: don't architect against the old Checkout API. Shopify deprecated the relevant Checkout APIs and directs headless implementations toward the Storefront Cart API/Checkout Kit. Shopify

The architecture I'd aim for

Rather than:

Frontend → Commerce platform → Checkout

I'd design:

Frontend(s)
→ Checkout API / Checkout BFF
→ Commerce platform
→ Payment provider
→ Tax / fraud / promotions / fulfillment

That gives you a stable checkout contract such as:

POST /checkout
POST /checkout/{id}/items
POST /checkout/{id}/shipping-address
POST /checkout/{id}/shipping-method
POST /checkout/{id}/payment
POST /checkout/{id}/complete

Your web app, native app, kiosk, marketplace UI, or future AI shopping interface can all consume the same checkout capability.

The key question is therefore how much of that checkout domain you want the commerce vendor to own:

• Vendor owns most of it: Shopify
• Vendor provides composable checkout primitives: commercetools
• You own the domain logic, platform supplies commerce primitives: Saleor / Medusa
• You want checkout to be a genuinely independent business capability: commercetools or Saleor are the first two I'd investigate.

If you tell me your stack (e.g. Next.js/React), B2C vs B2B, payment provider, countries, and whether checkout has bespoke logic, I can narrow this to a concrete architecture and platform choice.

If checkout is strategically important and you expect unusual flows, I'd start with Saleor or commercetools.

commercetools is particularly interesting if you want checkout to become an independently evolving service. Its Checkout product has a dedicated Checkout API, and the SDKs support it directly; the platform is designed around composable commerce rather than treating headless as primarily a storefront concern. commercetools Documentation commercetools Documentation

Saleor is compelling if you want maximum control without building the entire commerce engine yourself. Its APIs are GraphQL-native, and Saleor explicitly supports decoupling the frontend while extending commerce behavior through APIs/webhooks. Saleor Commerce Saleor Commerce

Medusa makes sense if your team is strongly TypeScript/Node-oriented and wants to own the checkout domain. Its modular architecture is well suited to replacing pieces of the standard checkout rather than fighting a SaaS platform's prescribed flow. PowerGate Software OSSAlt

Shopify is the operationally simpler choice. Its current Storefront API supports custom storefronts, carts and checkout, and Shopify explicitly supports bringing your own frontend/framework. However, there's an important architectural distinction: you're consuming Shopify's checkout infrastructure rather than owning an independently deployable checkout domain. Shopify Shopify

One important Shopify detail: don't architect against the old Checkout API. Shopify deprecated the relevant Checkout APIs and directs headless implementations toward the Storefront Cart API/Checkout Kit. Shopify

The architecture I'd aim for

Rather than:

Frontend → Commerce platform → Checkout

I'd design:

Frontend(s)
→ Checkout API / Checkout BFF
→ Commerce platform
→ Payment provider
→ Tax / fraud / promotions / fulfillment

That gives you a stable checkout contract such as:

POST /checkout
POST /checkout/{id}/items
POST /checkout/{id}/shipping-address
POST /checkout/{id}/shipping-method
POST /checkout/{id}/payment
POST /checkout/{id}/complete

Your web app, native app, kiosk, marketplace UI, or future AI shopping interface can all consume the same checkout capability.

The key question is therefore how much of that checkout domain you want the commerce vendor to own:

• Vendor owns most of it: Shopify
• Vendor provides composable checkout primitives: commercetools
• You own the domain logic, platform supplies commerce primitives: Saleor / Medusa
• You want checkout to be a genuinely independent business capability: commercetools or Saleor are the first two I'd investigate.

If you tell me your stack (e.g. Next.js/React), B2C vs B2B, payment provider, countries, and whether checkout has bespoke logic, I can narrow this to a concrete architecture and platform choice.

If the goal is specifically “checkout should no longer be coupled to our current frontend”, I’d shortlist commercetools, Saleor, and Shopify, but my default recommendation would be commercetools for a business that wants maximum checkout flexibility.

My ranking

1. commercetools — my pick for your requirement

commercetools is explicitly built around separating frontend experiences from commerce capabilities. Its APIs expose independent capabilities such as carts, orders, customers, pricing and promotions, rather than forcing the frontend to own the checkout implementation. commercetools commercetools Documentation

More importantly, its current Checkout product supports two modes:

• Complete Checkout — use commercetools for the checkout experience while keeping the frontend decoupled.
• Payment Only — retain your own checkout flow while using commercetools for payment functionality. commercetools Documentation commercetools Documentation

That second option is particularly interesting if your architectural goal is:

             ┌── Web frontend
             ├── Mobile app
             ├── Native app
             ├── Kiosk
             └── Future channel
                     │
                     ▼
              Checkout / BFF
                     │
          ┌──────────┴──────────┐
          ▼                     ▼
   Commerce platform       Payment services
   carts/pricing/etc.       PSPs/fraud/etc.

You can also build a custom checkout using the underlying APIs rather than adopting a prescribed checkout UI. commercetools explicitly documents both prebuilt and custom checkout approaches. commercetools Documentation

That's the strongest match if "decouple checkout" means we want checkout to become its own independently deployable capability.

2. Saleor — strongest alternative if your engineering team wants control

Saleor is worth serious consideration if you want an API-first/open-source architecture.

Saleor is GraphQL-native and positions both its storefront and admin APIs as fully headless. It also supports arbitrary frontend stacks and an app/webhook model for extending functionality. Saleor Saleor

I'd choose Saleor over commercetools if:

• You want to own more of the infrastructure.
• Your engineering organization is comfortable building commerce capabilities.
• Checkout logic is unusually bespoke.
• Avoiding vendor lock-in is a major requirement.
• You want to treat payments, shipping, promotions, etc. as composable services.

The tradeoff is that you own more of the complexity.

3. Shopify — great commerce platform, but I'd be more cautious here

Shopify absolutely supports headless storefronts. Its Storefront API gives a frontend access to products, carts, pricing and checkout, and Shopify's current API allows a cart to return a checkoutUrl for Shopify's web checkout. Shopify Shopify

So you can do:

Your frontend
     │
     ▼
Storefront API
     │
     ▼
Shopify Cart
     │
     ▼
Shopify Checkout

That's excellent if what you mean by decouple is:

"Our React/Next/etc. frontend shouldn't contain commerce logic."

But it's less ideal if you mean:

"Checkout itself needs to be an independently controlled application/service that we can radically customize."

Shopify's strength is that Shopify owns the hard parts of checkout. That's a feature, but also the boundary you'll run into if your checkout requirements become unusual.

What I'd do

If you're making an architectural decision today, I'd evaluate them this way:

Choose commercetools if checkout is becoming a strategic platform capability and you want maximum flexibility without building an entire commerce engine yourself.

Choose Saleor if you have a strong engineering team and want maximum ownership/control.

Choose Shopify if checkout requirements are relatively conventional and your priority is getting a robust commerce backend running quickly.

For your stated requirement, I'd start with commercetools. Its combination of independent APIs + custom checkout + Payment Only mode gives you an unusually clean migration path: you can decouple the frontend first, then progressively move checkout responsibilities out of the frontend without having to make the entire architecture change at once. commercetools Documentation commercetools Documentation

docs.commercetools.com
docs.commercetools.com

If you tell me your current stack (e.g. Shopify/Magento/custom), B2C vs B2B, payment provider, and how custom the checkout needs to be, I can narrow this to a specific architecture and migration plan.

If the goal is specifically to decouple checkout from the frontend—so checkout becomes a backend capability that can be consumed by web, mobile, kiosks, marketplaces, or future channels—I’d shortlist commercetools, Saleor, and Medusa, with the right choice depending heavily on how much commerce infrastructure you want to own.

My recommendation

1. commercetools — best for enterprise composable checkout

My default choice if you're an established enterprise.

commercetools has a dedicated Checkout product with APIs and SDKs, and importantly it supports both:

• Complete Checkout — commercetools manages the checkout orchestration while you provide the experience.
• Payment Only — keep your own checkout flow while using commercetools for payment processing/order creation. commercetools Documentation commercetools Documentation

That makes it particularly interesting if your architectural goal is:

                ┌── Web frontend
                ├── Mobile app
                ├── In-store
                ├── Marketplace
                └── Future channels
                         │
                         ▼
                  Checkout API
                         │
              ┌──────────┼──────────┐
              ▼          ▼          ▼
            Cart      Payments    Orders
              │          │          │
              └──────────┼──────────┘
                         ▼
                  Commerce backend

You aren't making React/Next.js/etc. the owner of checkout business logic.

It also has a useful abstraction around payment providers through commercetools Connect, rather than forcing your frontend to understand individual PSP integrations. commercetools Documentation

Best when: enterprise scale, multiple markets/channels, complex pricing/promotions/B2B, and you want managed infrastructure.

Downside: more expensive and architecturally heavyweight than the open-source alternatives.

2. Saleor — best if checkout itself is a strategic differentiator

I'd seriously consider Saleor if you want the checkout to be extremely programmable.

Saleor is GraphQL-native and explicitly designed around API-first/headless commerce. Its Checkout API covers things such as anonymous checkout, multiple payments, split fulfillment, multiple gateways, custom checkout completion flows, stock reservation, shipping, and multi-channel commerce. Saleor Commerce Saleor Commerce

That gives you a model more like:

Frontend
   │
   ▼
Your Checkout Experience
   │
   ▼
Your BFF / API layer
   │
   ▼
Saleor Checkout API
   │
   ├── Pricing
   ├── Promotions
   ├── Inventory
   ├── Payments
   ├── Shipping
   └── Order creation

The particularly important part is custom checkout completion. If your checkout has unusual orchestration—multiple payment instruments, subscriptions, split fulfillment, marketplace logic, etc.—Saleor gives you a lot of room to make that logic your own. Saleor Commerce

Best when: engineering-led organization, highly customized checkout, composable architecture, desire to minimize vendor lock-in.

Downside: you'll own more of the architecture and operational complexity than with a conventional SaaS commerce platform.

3. Medusa — best for maximum engineering control

Medusa is worth considering if your team wants the commerce backend to behave more like an application platform than a traditional ecommerce package.

It's particularly attractive when you want to write substantial amounts of your own checkout/business logic and you're comfortable owning the resulting infrastructure. Recent comparisons continue to position it as one of the strongest open-source options for custom commerce systems. PowerGate Software Vendure

I'd choose Medusa over Saleor if your team strongly prefers a Node/TypeScript-centric architecture and wants maximum control over the implementation.

How I'd rank them for your requirement

One important architectural distinction

I wouldn't frame the decision as "which platform has a headless checkout?"

Almost all modern commerce platforms can technically do that.

I'd ask:

Where should checkout business logic live, and who should own it?

For example, if you want to eventually support:

                 Checkout Domain
                       │
       ┌───────────────┼────────────────┐
       │               │                │
    Website          iOS/Android      Retail
       │               │                │
       └───────────────┼────────────────┘
                       │
                 Checkout API
                       │
       ┌───────────────┼────────────────┐
       │               │                │
    Pricing         Payments         Fulfillment

then don't let the frontend become the orchestration layer.

The frontend should ideally be responsible for presentation and collecting user input. A backend/BFF or commerce API should own:

• cart state
• address validation
• shipping selection
• promotions
• tax calculation
• inventory validation
• payment orchestration
• fraud/risk decisions
• order creation
• idempotency
• checkout state transitions

That's where Saleor and commercetools become especially compelling.

What I'd pick

Enterprise / high-complexity commerce: commercetools.

Engineering-heavy company wanting maximum checkout flexibility: Saleor.

Smaller engineering-led team wanting an open-source TypeScript commerce engine: Medusa.

If you tell me your current stack (e.g. Shopify/Magento/custom), order volume, B2B vs B2C, payment provider, and how custom the checkout needs to be, I can narrow this down to a specific architecture and migration path.

Saleor is GraphQL-native and explicitly designed around API-first/headless commerce. Its Checkout API covers things such as anonymous checkout, multiple payments, split fulfillment, multiple gateways, custom checkout completion flows, stock reservation, shipping, and multi-channel commerce. Saleor Commerce Saleor Commerce

That gives you a model more like:

Frontend
   │
   ▼
Your Checkout Experience
   │
   ▼
Your BFF / API layer
   │
   ▼
Saleor Checkout API
   │
   ├── Pricing
   ├── Promotions
   ├── Inventory
   ├── Payments
   ├── Shipping
   └── Order creation

The particularly important part is custom checkout completion. If your checkout has unusual orchestration—multiple payment instruments, subscriptions, split fulfillment, marketplace logic, etc.—Saleor gives you a lot of room to make that logic your own. Saleor Commerce

Best when: engineering-led organization, highly customized checkout, composable architecture, desire to minimize vendor lock-in.

Downside: you'll own more of the architecture and operational complexity than with a conventional SaaS commerce platform.

3. Medusa — best for maximum engineering control

Medusa is worth considering if your team wants the commerce backend to behave more like an application platform than a traditional ecommerce package.

It's particularly attractive when you want to write substantial amounts of your own checkout/business logic and you're comfortable owning the resulting infrastructure. Recent comparisons continue to position it as one of the strongest open-source options for custom commerce systems. PowerGate Software Vendure

I'd choose Medusa over Saleor if your team strongly prefers a Node/TypeScript-centric architecture and wants maximum control over the implementation.

How I'd rank them for your requirement

One important architectural distinction

I wouldn't frame the decision as "which platform has a headless checkout?"

Almost all modern commerce platforms can technically do that.

I'd ask:

Where should checkout business logic live, and who should own it?

For example, if you want to eventually support:

                 Checkout Domain
                       │
       ┌───────────────┼────────────────┐
       │               │                │
    Website          iOS/Android      Retail
       │               │                │
       └───────────────┼────────────────┘
                       │
                 Checkout API
                       │
       ┌───────────────┼────────────────┐
       │               │                │
    Pricing         Payments         Fulfillment

then don't let the frontend become the orchestration layer.

The frontend should ideally be responsible for presentation and collecting user input. A backend/BFF or commerce API should own:

• cart state
• address validation
• shipping selection
• promotions
• tax calculation
• inventory validation
• payment orchestration
• fraud/risk decisions
• order creation
• idempotency
• checkout state transitions

That's where Saleor and commercetools become especially compelling.

What I'd pick

Enterprise / high-complexity commerce: commercetools.

Engineering-heavy company wanting maximum checkout flexibility: Saleor.

Smaller engineering-led team wanting an open-source TypeScript commerce engine: Medusa.

If you tell me your current stack (e.g. Shopify/Magento/custom), order volume, B2B vs B2C, payment provider, and how custom the checkout needs to be, I can narrow this down to a specific architecture and migration path.

If the goal is specifically to decouple checkout from the frontend—so checkout is a commerce capability that multiple clients can consume—I’d shortlist commercetools, Saleor, Medusa, and Shopify Plus, but they make very different architectural tradeoffs.

My recommendation

For maximum checkout flexibility: commercetools.

It is the strongest fit if you're building a genuinely composable architecture where the frontend, checkout UX, payments, promotions, customer identity, and potentially OMS are independently replaceable. The downside is substantially more engineering and operational complexity.

For an engineering-led team that wants to own the checkout domain: Medusa or Saleor.

• Medusa — my pick if your team is primarily TypeScript/Node. It's highly moddable and makes sense when checkout rules are a competitive differentiator.
• Saleor — particularly attractive if you want a GraphQL-first, API-native architecture and sophisticated multi-channel/B2B requirements. Saleor explicitly positions its checkout and admin APIs as fully headless. Saleor Commerce

For the fastest path with the least operational burden: Shopify Plus.

Shopify's current architecture is quite good for headless frontends: its Storefront API lets you build the storefront on essentially any frontend stack, while Shopify owns the underlying commerce infrastructure. Shopify

But there's an important distinction: Shopify does not give you an entirely independent checkout engine. Your headless frontend ultimately hands the cart off to Shopify's checkout. The current Cart API exposes a checkoutUrl for that transition. Shopify Shopify

Also, don't architect around Shopify's old Checkout API—the Checkout APIs were deprecated and sunset in favor of the Storefront Cart API. Shopify Shopify

How I'd think about the decision

The key architectural question I'd ask your team is:

Do you want to decouple the checkout UI, or decouple the checkout domain?

If you mean UI—you want Next.js/mobile/in-store/etc. to have different experiences while the underlying checkout remains managed—Shopify Plus is probably the pragmatic choice.

If you mean domain—you want your own checkout service/API that can be called by web, mobile, conversational commerce, kiosks, marketplaces, etc., and you don't want the frontend coupled to a particular vendor's checkout—you should look much harder at commercetools, Saleor, or Medusa.

For a new architecture, I'd probably structure it roughly as:

                ┌── Web
                ├── Mobile
                ├── App
                ├── POS
                └── Other channels
                         │
                         ▼
                  Checkout API
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
       Cart          Pricing         Customer
          │              │              │
          └──────────────┼──────────────┘
                         ▼
                    Payments
                         │
                         ▼
                       OMS

That gives you a stable checkout contract independent of whichever frontend framework you use—and, importantly, lets you change the frontend without rewriting checkout logic.

If you tell me your rough scale (GMV/orders), B2C vs B2B, geography, payment provider, and whether you're on AWS/GCP/Azure, I can narrow this to a 2–3 platform recommendation and propose the target checkout architecture.

If the goal is to decouple checkout from the frontend and support highly flexible, composable buying experiences (web, mobile, kiosks, marketplaces, apps, AI agents, etc.), I would avoid platforms where checkout is tightly coupled to a storefront theme/runtime. You want a commerce engine that exposes cart, pricing, promotions, inventory, customer, checkout, payment, and order orchestration as APIs. commercetools

The strongest options are:

1. commercetools — best fit for truly headless checkout

Best for: Enterprise teams building a custom checkout experience.

Why it stands out:

• Checkout is API-first and designed for composable architectures.
• Supports a "complete checkout" model or a "payment only" model, meaning you can own the checkout UX while delegating payment processing. commercetools Documentation commercetools Documentation
• Strong support for complex pricing, promotions, multi-market, B2B, and omnichannel flows.
• Fits well if you want to swap payment providers, tax engines, fraud systems, CMS, search, etc. commercetools

Typical architecture:

Frontend (React / Next.js / Mobile App)
          |
          v
Checkout Orchestration Layer (your BFF)
          |
          +--> commercetools Cart API
          +--> commercetools Checkout API
          +--> Payment Provider (Adyen/Stripe/etc.)
          +--> Tax Engine
          +--> OMS / ERP

Tradeoff:

• Requires stronger engineering ownership.
• More architecture work than SaaS-first platforms.

2. Shopify — best if you want speed but need some headless

Best for: Brands that want a fast implementation and a large ecosystem.

Shopify can support headless storefronts through its APIs, but checkout customization is historically more constrained than fully composable platforms. It works well if your checkout requirements are close to Shopify’s model.

Good fit:

• DTC brands
• Standard carts
• Standard promotions
• Fast launches

Less ideal:

• Custom checkout logic
• Marketplace flows
• Complex B2B buying journeys
• Multiple commerce backends

3. Salesforce Commerce Cloud — best for enterprise CRM-heavy organizations

Best for: Large enterprises already invested in Salesforce.

Strengths:

• Strong customer data integration.
• Headless APIs and composable storefront capabilities. Salesforce
• Good for B2C/B2B organizations with complex customer journeys.

Tradeoff:

• More ecosystem dependency.
• Usually heavier implementation and governance.

4. BigCommerce — pragmatic headless SaaS option

Best for: Companies wanting SaaS operations with more API flexibility than traditional platforms.

Strengths:

• Easier operational model than composable platforms.
• Good catalog and commerce APIs.

Tradeoff:

• Less flexible than commercetools for deeply customized checkout orchestration.

5. Medusa or Saleor — best if you want maximum control

Best for: Engineering-led companies that want to own the commerce stack.

Strengths:

• Open source.
• Full control over checkout logic.
• Easier to customize unusual flows.

Tradeoff:

• You own more infrastructure, scaling, and operational complexity.

My recommendation by scenario

For a serious frontend/checkout decoupling initiative, I would shortlist:

1. commercetools (most future-proof composable option)
2. Salesforce Commerce Cloud (if Salesforce ecosystem matters)
3. Shopify (if business speed outweighs checkout flexibility)

A key architectural question is whether you want to decouple only the checkout UI or decouple the entire commerce domain (cart, pricing, promotions, inventory, order management). The answer changes the platform choice significantly.

If the goal is to decouple checkout from the frontend, I would evaluate platforms less on “do they support headless?” and more on:

• Checkout API maturity — can your frontend own the UX while the commerce engine owns cart/order/payment state?
• Workflow extensibility — can you inject custom logic (pricing, promos, fraud, fulfillment, eligibility)?
• Payment orchestration — multiple PSPs, wallets, saved payment methods, split payments, etc.
• Composable architecture — can checkout evolve independently from catalog, CMS, search, tax, OMS?
• Operational burden — SaaS convenience vs full control.

The strongest candidates:

PowerGate Software Naturaily## My shortlist by scenario

1. You want a truly independent checkout platform

Choose:

• commercetools
• Saleor

These are closest to the “checkout is a service” model. commercetools has an API-driven checkout product supporting both complete checkout ownership and payment-only modes. commercetools Documentation Saleor exposes checkout capabilities through APIs, including custom checkout flows, multiple payments, anonymous checkout, split fulfillment, and multi-gateway scenarios. Saleor Commerce

Typical architecture:

Frontend (Next.js / React Native / Mobile / Kiosk)
              |
              |
       Checkout API layer
              |
   -------------------------
   |          |            |
Commerce   Payments     OMS
Engine     PSPs         ERP/WMS

2. You have complex checkout rules

Examples:

• B2B approvals
• negotiated pricing
• subscriptions + one-time items
• marketplace checkout
• regional tax/payment differences
• complex fulfillment splitting

I would lean:

1. commercetools
2. Saleor
3. Medusa

Medusa is attractive when you want developers to directly modify commerce workflows because it is a modular, developer-oriented commerce backend. Eryx Innovations Lab

3. You mainly want a custom frontend but standard checkout

Use:

• Shopify headless
• BigCommerce headless

You get:

• mature payments
• merchant tooling
• lower operational overhead

But you should validate whether your checkout roadmap fits within platform boundaries. Many teams discover that “headless storefront” does not automatically mean “fully headless checkout.”

Architecture I would recommend

For a modern decoupled checkout:

             Web / App / POS
                    |
              Experience API
                    |
        ------------------------
        |                      |
    Checkout Service       Commerce Core
        |                      |
 Payment orchestration     Catalog
        |                  Inventory
   Stripe/Adyen/etc        Pricing
        |
     Fraud + Tax
        |
       Order
        |
       OMS

I would avoid putting all checkout behavior directly in the frontend. The frontend should own:

• layout
• interaction
• validation UX
• progressive checkout steps

The backend should own:

• cart state
• pricing decisions
• promotions
• inventory reservation
• payment state machine
• order creation

Recommendation

For most enterprises building a next-generation headless checkout, I would rank:

1. commercetools — best long-term composable architecture
2. Saleor — best balance of API flexibility and control
3. Medusa — best if your engineering team wants to own the stack
4. Shopify headless — best if speed and operational simplicity matter more than checkout freedom

The deciding question is: do you want to replace only the storefront, or do you want checkout itself to become a composable business capability? If it is the latter, I would not start with a traditional commerce platform.

Recommendation

For most enterprises building a next-generation headless checkout, I would rank:

1. commercetools — best long-term composable architecture
2. Saleor — best balance of API flexibility and control
3. Medusa — best if your engineering team wants to own the stack
4. Shopify headless — best if speed and operational simplicity matter more than checkout freedom

The deciding question is: do you want to replace only the storefront, or do you want checkout itself to become a composable business capability? If it is the latter, I would not start with a traditional commerce platform.

If the goal is specifically “checkout should be an independent commerce capability that our frontend can consume through APIs”, I’d shortlist commercetools, Saleor, and Medusa, with Shopify as the pragmatic option if you don't need complete control over checkout.

My recommendation

1. commercetools — best for enterprise-grade decoupling

This would be my first choice if you're building a serious composable commerce architecture.

• Checkout is exposed as a dedicated API/service rather than being tied to a storefront.
• It supports both Complete Checkout and Payment Only modes, so you can own the UX while outsourcing payment infrastructure where appropriate. Commercetools Documentation Commercetools Documentation
• Its Checkout APIs are explicitly designed for programmatic access, and there's a browser SDK as well as APIs you can consume from a BFF. Commercetools Documentation Commercetools Documentation
• Good fit if you expect multiple frontends: web, mobile, kiosks, marketplaces, etc.

2. Saleor — best if you want maximum checkout flexibility

I'd seriously consider Saleor if your engineering team is comfortable owning more of the architecture.

• It is API-only and GraphQL-native, with no requirement that the frontend use a particular framework. Saleor Commerce GitHub
• Checkout is a first-class API with support for things like split payments, split fulfillment, multiple payment gateways, anonymous checkout, stock reservation, and custom checkout completion flows. Saleor Commerce
• This is particularly attractive if “checkout” is becoming a domain service that needs to evolve independently from your presentation layer.

3. Medusa — best if you want an open, developer-owned stack

Medusa is compelling when you want to own the implementation rather than adopt a large enterprise commerce platform. Its checkout flow is modular—you can combine or reorder email, address, shipping, payment, and order-completion steps. Medusa Documentation

4. Shopify — best if minimizing operational complexity matters more than checkout control

Shopify's Storefront API is very good for headless storefronts and lets you use essentially any frontend stack. Shopify Shopify

But there's an important architectural distinction: Shopify's model still centers checkout around Shopify Checkout. Their own documentation describes headless storefronts as replacing the frontend while customers ultimately check out using Shopify Checkout. Shopify Help Center

So I'd choose Shopify if you mean:

“We want the frontend independent of Shopify.”

I'd choose commercetools/Saleor if you mean:

“We want checkout itself to be an independent backend capability that we can completely orchestrate.”

The architecture I'd target

I'd avoid having the browser talk directly to the commerce platform for the entire checkout lifecycle. Instead:

                 ┌──────────────────┐
 Web / Mobile ──►│                  │
 Kiosk / App ───►│  Checkout BFF    │
                 │                  │
                 └────────┬─────────┘
                          │
             ┌────────────┼─────────────┐
             ▼            ▼             ▼
        Commerce       Payments      Shipping
        Platform       Provider       / Tax
             │
             ▼
          Orders

The Checkout BFF becomes your stable contract:

POST   /checkout
GET    /checkout/:id

POST   /checkout/:id/items
PATCH  /checkout/:id/customer
PATCH  /checkout/:id/address
POST   /checkout/:id/shipping
POST   /checkout/:id/payment
POST   /checkout/:id/complete

That gives you the key property you're after: the frontend doesn't know or care whether checkout is powered by commercetools, Saleor, or something else later.

What I'd pick

For a new enterprise architecture: commercetools.
For maximum engineering/control: Saleor.
For an open-source, highly customizable stack: Medusa.
For fastest path to production with less commerce infrastructure: Shopify.

If you tell me your current frontend/backend stack, B2C vs B2B, payment provider, and whether you need multi-region/multi-currency, I can narrow this to a concrete recommendation and architecture.

If the goal is to decouple checkout from the frontend and support flexible, custom checkout journeys, I would focus less on “headless storefront” and more on checkout API maturity. Many platforms advertise headless, but the real question is whether checkout is a first-class API capability (cart → pricing → promotions → payments → tax → shipping → order creation) rather than a frontend widget you have to fight. Vendure Your Next Store

A shortlist I would consider:

Vendure Naturaily## My recommendation by scenario

1. You want a completely custom checkout engine

Choose:

• commercetools
• Commerce Layer
• Medusa

These let your frontend own the experience while the commerce backend provides APIs for:

• cart lifecycle
• pricing
• promotions
• inventory checks
• customer identity
• payment orchestration
• order creation
• fulfilment workflows

This is the closest model to “checkout as a service.” Vendure Guideflow

2. You want to migrate away from a monolithic frontend but keep operational simplicity

Choose:

• Shopify Plus
• BigCommerce

You get:

• managed payments integrations
• tax/shipping ecosystem
• admin tooling
• less infrastructure

But you should validate checkout extensibility early. These platforms are often “headless storefront” solutions rather than completely replaceable commerce engines. Naturaily Shopify

Architecture I would aim for

A modern setup usually looks like:

Frontend (Web / App / Kiosk / Agent)
              |
              v
Checkout API Layer
              |
      -----------------
      |               |
 Commerce Engine   Payment Service
      |
 Inventory / Pricing / Promotions
      |
 Order Management

The key design decision: do not put business rules in the frontend.

Your frontend should ask:

• “Create cart”
• “Apply promotion”
• “Calculate totals”
• “Validate shipping option”
• “Complete checkout”

It should not decide:

• tax rules
• discount eligibility
• inventory reservation
• order state transitions

What I would avoid

I would be cautious with platforms where “headless” means:

“You can build a custom React storefront, but checkout still expects our hosted flow.”

That creates a split architecture where your product team wants flexibility but the most important conversion surface is still locked.

If I were choosing today

• Large enterprise / global commerce: commercetools
• Engineering-heavy company building differentiated checkout: Medusa or Commerce Layer
• Fastest route with lower operational burden: Shopify Plus
• B2B or complex pricing: commercetools or Adobe Commerce

The right choice depends heavily on whether you are replacing only the frontend or trying to make checkout itself a reusable capability across web, mobile, marketplaces, stores, and future channels. Shopify

If the goal is specifically “checkout should be a commerce capability independent of our frontend”, I’d shortlist commercetools, Saleor, Medusa, and Shopify—but they represent very different levels of decoupling.

My recommendation

For maximum checkout flexibility: commercetools.
For a modern engineering-led team: Medusa.
For GraphQL + enterprise/B2B: Saleor.
For fastest launch / lowest operational burden: Shopify Plus.

Why I'd look hardest at commercetools

If by decouple checkout you mean that checkout should become a backend service/API, rather than “our React/Next.js app happens to render a checkout,” commercetools is probably the cleanest enterprise architecture.

Its Checkout API can be accessed independently through its SDKs, including TypeScript, Java and .NET. commercetools Documentation

That lets you architect something like:

             ┌───────────────┐
             │   Web / Next   │
             └───────┬───────┘
                     │
             ┌───────▼───────┐
             │   Checkout    │
             │   BFF / API   │
             └───────┬───────┘
                     │
        ┌────────────┴────────────┐
        │      Commerce API       │
        │  cart / pricing / tax   │
        │  inventory / checkout   │
        └────────────┬────────────┘
                     │
       ┌─────────────┼─────────────┐
       ▼             ▼             ▼
    Payments       OMS/ERP       Customer

Your checkout UI can then be replaced independently—web, mobile, kiosk, embedded checkout, etc.—without making the commerce engine the frontend.

Where Medusa gets interesting

I'd choose Medusa instead if you have a strong engineering organization and want to own the checkout domain rather than buy into an enterprise composable platform.

It's particularly attractive if checkout contains genuinely proprietary business logic: unusual promotions, marketplace behavior, custom fulfillment rules, complex payment orchestration, etc. Current 2026 comparisons consistently position Medusa as a strong choice for custom checkout and developer-controlled commerce. Ribbsaeter Systems Naturaily

The tradeoff is that you're taking on considerably more of the commerce infrastructure yourself.

Saleor is the dark horse

If your organization is comfortable with GraphQL/Python, I'd put Saleor very high on the list. Its architecture is explicitly API-first: its storefront and admin are headless, and checkout functionality isn't dependent on a particular frontend technology. Saleor Commerce

It's especially compelling if you're heading toward:

• B2B
• multiple markets/channels
• multiple warehouses
• sophisticated pricing
• multiple frontend applications

I wouldn't choose Shopify if “checkout independence” is the primary requirement

Shopify is genuinely headless: its Storefront API supports products, carts and checkout, and you can use essentially any frontend framework. Shopify Shopify

But there's an important architectural distinction:

Shopify decouples the storefront from Shopify checkout; it doesn't really give you an independent checkout engine.

You're still ultimately operating within Shopify's checkout model. Shopify's own documentation describes the custom storefront as independent from the backend, but the commerce engine remains Shopify. Shopify

That's perfectly fine if your requirement is:

“We want our own frontend but don't want to build checkout.”

It's less ideal if the requirement is:

“Checkout itself needs to be an independently deployable/composable commerce capability.”

Also, be careful with older Shopify architecture recommendations: Shopify deprecated its older Checkout APIs and moved developers toward the Storefront Cart API/Checkout Kit. Shopify

What I'd do

If you're making an architecture decision today, I'd run a proof-of-concept with commercetools + Medusa + Saleor, rather than comparing 20 commerce platforms.

I'd evaluate them against these exact checkout capabilities:

1. Cart lifecycle — can the cart exist independently of any UI?
2. Checkout state machine — can you control the states and transitions?
3. Payment orchestration — Stripe/Adyen/etc. without frontend coupling.
4. Promotions — arbitrary/custom promotion logic.
5. Tax — external tax engines and market-specific rules.
6. Inventory reservation — especially concurrency and expiration.
7. Customer identity — guest → authenticated transition.
8. Multi-channel — web, mobile, POS, marketplace, etc.
9. Idempotency — particularly around payment/order creation.
10. Events/webhooks — checkout events should drive downstream systems.
11. Observability — checkout should be diagnosable independently of the frontend.
12. Ability to replace the frontend entirely without changing checkout.

If “checkout is a product/service in its own right” is the architectural north star, my first choice would be commercetools. If you want that same architectural freedom but want to own more of the stack, I'd choose Medusa.

If you tell me your GMV/scale, B2C vs B2B, payment provider, current frontend (Next.js/etc.), and whether you want SaaS vs self-hosted, I can narrow this to a specific architecture and platform recommendation.

“We want our own frontend but don't want to build checkout.”

It's less ideal if the requirement is:

“Checkout itself needs to be an independently deployable/composable commerce capability.”

Also, be careful with older Shopify architecture recommendations: Shopify deprecated its older Checkout APIs and moved developers toward the Storefront Cart API/Checkout Kit.

What I'd do

If you're making an architecture decision today, I'd run a proof-of-concept with commercetools + Medusa + Saleor, rather than comparing 20 commerce platforms.

I'd evaluate them against these exact checkout capabilities:

Saleor is the dark horse

If the goal is to decouple checkout from the front end (i.e., your frontend owns the UX and checkout flow, while commerce services provide APIs for cart, pricing, inventory, promotions, payments, and orders), you should evaluate platforms based less on “headless storefront” capability and more on checkout composability.

The right choice depends heavily on how much checkout logic you want to own.

Shortlist

Naturaily Ribbsaeter Systems## My recommendation by scenario

1. You want a truly independent checkout layer → commercetools

Choose commercetools if you need things like:

• Completely custom checkout UI
• Complex pricing rules
• Multiple carts
• Marketplace flows
• B2B account structures
• Custom payment orchestration
• Multiple frontend channels (web, mobile, kiosks, IoT)
• Ability to swap payment/tax/shipping providers independently

Its composable model is designed around APIs and services rather than a storefront-first architecture. Its Checkout capabilities support both a complete checkout mode and payment-only scenarios. commercetools Documentation

Architecture example:

Next.js / React / Mobile Apps
          |
          |
Checkout Orchestration Service
          |
          |
+-----------------------------+
| commercetools                |
| - Cart                       |
| - Pricing                    |
| - Inventory                  |
| - Orders                     |
| - Customer                   |
+-----------------------------+
          |
          |
Payments / Tax / Shipping APIs

This is usually the strongest option when checkout itself is a strategic product capability.

2. You want headless but don't want to rebuild commerce → Shopify Plus

Choose Shopify Plus if:

• You are primarily DTC
• You need speed
• Your checkout requirements are mostly standard
• Your team wants strong operational tooling

Shopify supports headless storefronts through its Storefront API, including product, cart, and checkout workflows. Shopify

The limitation: Shopify is intentionally opinionated around checkout. You can create custom experiences around checkout, but if you want a completely bespoke checkout engine, you may eventually fight the platform.

3. You need more checkout control than Shopify but less complexity than commercetools → BigCommerce

BigCommerce is often a good middle ground.

It supports:

• Headless storefronts
• Custom checkout experiences
• Checkout APIs
• Embedded checkout
• API-driven cart/order flows

BigCommerce documents support for custom checkout experiences using APIs and SDKs, including building checkout outside the native storefront context. BigCommerce BigCommerce

Good fit if you want:

Custom frontend
       |
Custom checkout UI
       |
BigCommerce APIs
       |
Payments + fulfillment

without taking on the full responsibility of a composable commerce stack.

Platforms I would avoid for this specific requirement

Traditional Magento / Adobe Commerce

Powerful, but if your primary goal is checkout decoupling, you may end up managing a lot of infrastructure that composable platforms solve more cleanly.

Pure CMS + plugins

A headless CMS plus payment providers can work, but you will quickly recreate:

• cart state
• promotions
• tax logic
• inventory reservation
• order management
• fraud workflows

Decision framework

Ask these questions:

How much checkout do you want to own?

Mostly standard checkout
→ Shopify Plus

Custom UX, but standard commerce rules
→ BigCommerce

Checkout is a competitive differentiator
→ commercetools

You want total code ownership
→ Medusa / Saleor-style architecture

My default recommendation

For most companies saying “we need to decouple checkout from the frontend”, I would shortlist:

1. commercetools — if checkout flexibility is the primary requirement
2. BigCommerce — if you want flexibility without a huge composable investment
3. Shopify Plus — if operational simplicity matters more than checkout freedom

The key architectural question is: Do you want checkout to be a UI you build, or a business capability you own? If it is the latter, I would lean toward commercetools or an API-first commerce engine.

Traditional Magento / Adobe Commerce

Powerful, but if your primary goal is checkout decoupling, you may end up managing a lot of infrastructure that composable platforms solve more cleanly.

Pure CMS + plugins

A headless CMS plus payment providers can work, but you will quickly recreate:

• cart state
• promotions
• tax logic
• inventory reservation
• order management
• fraud workflows

Decision framework

Ask these questions:

How much checkout do you want to own?

Mostly standard checkout
→ Shopify Plus

Custom UX, but standard commerce rules
→ BigCommerce

Checkout is a competitive differentiator
→ commercetools

You want total code ownership
→ Medusa / Saleor-style architecture

My default recommendation

For most companies saying “we need to decouple checkout from the frontend”, I would shortlist:

1. commercetools — if checkout flexibility is the primary requirement
2. BigCommerce — if you want flexibility without a huge composable investment
3. Shopify Plus — if operational simplicity matters more than checkout freedom

The key architectural question is: Do you want checkout to be a UI you build, or a business capability you own? If it is the latter, I would lean toward commercetools or an API-first commerce engine.

If the goal is specifically to decouple checkout from the frontend and make checkout a reusable commerce capability across web, mobile, apps, kiosks, and potentially agentic experiences, I’d shortlist commercetools, Saleor, and Medusa.

My recommendation

For an enterprise: commercetools.
It has the cleanest fit for a true composable architecture. Its Checkout product exposes checkout through APIs and supports both a complete checkout experience and a Payment Only mode, so you can keep your own checkout UX while outsourcing the difficult payment/order-completion infrastructure. It also explicitly supports building custom checkout flows directly against its commerce APIs. commercetools Documentation commercetools Documentation

commercetools.com

For maximum checkout/business-logic flexibility: Saleor.
I'd seriously consider Saleor if your checkout is going to contain unusual rules. Its API supports things like split payments, split fulfillments, custom pricing, custom shipping logic, multiple payment gateways, anonymous checkout, multi-currency, and custom checkout completion flows. It's GraphQL-native and explicitly designed to work independently of the frontend. Saleor Commerce Saleor Commerce

saleor.io

For maximum ownership/control: Medusa.
Medusa is attractive if you want the commerce engine to be highly programmable and potentially own/operate more of the stack. Its v2 architecture exposes commerce capabilities through REST APIs and separates domains such as carts, payments, fulfillment, promotions, inventory, and orders into modules that can be extended. Medusa Docs Medusa Docs

medusajs.com

How I'd think about the architecture

Rather than:

Frontend
   ↓
Commerce platform checkout
   ↓
Payment

I'd aim for:

                    ┌── Web
                    ├── Mobile
                    ├── Native app
                    ├── POS / kiosk
                    └── AI / agent
                          │
                          ▼
                  Checkout API / BFF
                          │
             ┌────────────┼────────────┐
             ▼            ▼            ▼
           Cart        Pricing      Customer
             │            │            │
             └────────────┼────────────┘
                          ▼
                       Payment
                          │
                          ▼
                         Order
                          │
                    Fulfillment

The important architectural decision is not just "headless commerce." I'd specifically require the platform to let you own the checkout state machine and orchestration layer rather than merely giving you a headless checkout page.

My ranking for your use case

One particularly important distinction: commercetools now gives you both a prebuilt Checkout product and the option to build custom checkout flows using its underlying APIs. That makes it unusually well aligned with your stated objective—you can decouple the frontend today without committing yourself to a permanently hosted/vendor-controlled checkout UX. commercetools Documentation commercetools Documentation

If you tell me your current stack (e.g. Shopify/Magento/custom), order volume, B2C vs. B2B, payment provider, and how customized the checkout logic needs to be, I can narrow this to a specific recommendation and proposed target architecture.

If the goal is specifically to decouple checkout from the frontend—so checkout becomes an independently deployable commerce capability—I’d shortlist Saleor, commercetools, and Shopify, but they’re quite different.

My recommendation

1. Saleor — best for maximum checkout flexibility

Saleor is the strongest fit if you literally want to own the checkout experience and have your frontend talk to commerce through APIs. Its checkout is GraphQL-native and supports things like multiple payment gateways, split payments, installments, anonymous checkout, and custom payment logic. It explicitly supports building checkout flows independently of the frontend stack. Saleor Commerce Saleor Commerce

This would let you architect something like:

                 ┌───────────────┐
Web / Mobile ───►│ Checkout BFF  │
                 └───────┬───────┘
                         │
                  ┌──────▼──────┐
                  │   Saleor    │
                  │ Cart/Order  │
                  │  Checkout   │
                  └───┬─────┬───┘
                      │     │
                ┌─────▼─┐ ┌─▼──────┐
                │Payment│ │Shipping│
                │Provider│ │Provider│
                └───────┘ └────────┘

That architecture is particularly attractive if you anticipate multiple frontends, native apps, unusual checkout flows, payment orchestration, or eventually replacing pieces of the commerce stack.

2. commercetools — best enterprise/composable choice

I'd choose commercetools if this is a large enterprise architecture and you want checkout to be a first-class service rather than something coupled to a storefront. Its Checkout product has a Complete Checkout mode as well as a Payment Only mode, and exposes APIs/SDKs for integrating checkout into different channels. commercetools Docs commercetools Docs

The Payment Only mode is especially interesting if you're gradually decoupling an existing checkout rather than replacing everything at once.

3. Shopify — best if operational simplicity matters more than checkout ownership

Shopify is excellent for headless storefronts: the Storefront API is framework-agnostic, and its Cart API handles cart construction before transitioning to Shopify's checkout. Shopify Shopify

But there's an important distinction: Shopify is headless at the storefront layer, not completely headless at checkout. The current Cart API ultimately provides a checkoutUrl that sends the buyer into Shopify's web checkout. Shopify Shopify's older Checkout APIs have also been deprecated/sunset in favor of the Cart API. Shopify

So if your requirement is:

"We want our React/Next/mobile frontend completely independent from checkout and want to own the checkout UX/orchestration."

I'd not make Shopify the first choice.

How I'd decide

If I were designing this today, I'd start with Saleor vs. commercetools, rather than Shopify. The key architectural principle I'd enforce is that the frontend should never own checkout state or payment orchestration. It should consume a checkout API/BFF, while the commerce platform owns cart/checkout state, pricing, promotions, inventory validation, tax, shipping, payment state, and order creation.

If you tell me your stack (Next.js/React/native/etc.), B2C vs B2B, payment provider, countries, and how much checkout customization you need, I can give you a concrete Saleor vs. commercetools architecture and recommendation.

If the goal is specifically “checkout should be a backend capability, not something coupled to our storefront”, I’d shortlist commercetools, Saleor, and Medusa—with commercetools as the strongest enterprise choice and Saleor as the strongest engineering-led/open-source choice.

My recommendation

1. commercetools — my default recommendation

commercetools is particularly well suited if checkout needs to become a domain service that multiple front ends consume.

Its Checkout product explicitly supports both:

• Complete Checkout — commercetools owns the checkout infrastructure/API while you build the experience.
• Payment Only — you retain your existing checkout flow while using commercetools for payment functionality. commercetools Documentation commercetools Documentation

That gives you a useful architecture:

                 ┌── Web storefront
                 ├── Mobile app
                 ├── POS
                 ├── Partner portal
                 └── AI / conversational UI
                         │
                         ▼
                 ┌─────────────────┐
                 │ Checkout API    │
                 │                 │
                 │ cart            │
                 │ pricing         │
                 │ promotions      │
                 │ shipping        │
                 │ tax             │
                 │ payment        │
                 │ order           │
                 └────────┬────────┘
                          │
                   Commerce backend

The important part is that the checkout lifecycle isn't owned by React/Next.js/etc. The frontend becomes an implementation of the checkout experience rather than the checkout itself.

commercetools also exposes Checkout APIs and SDKs specifically for programmatic integration, and its architecture is explicitly designed around separating experience layers from commerce capabilities. commercetools Documentation commercetools

I'd pick this if you're talking about a serious enterprise platform with multiple channels, complicated pricing/promotions, B2B, multiple markets, or a long-lived composable architecture.

docs.commercetools.com

2. Saleor — potentially even better if your team wants maximum API control

Saleor is extremely attractive for this particular architecture.

It's API-only and GraphQL-native, so there isn't really a concept of the commerce backend expecting to render your checkout. Saleor Commerce GitHub

Its Checkout API supports things like:

• anonymous checkout
• multiple checkouts per user
• custom checkout completion
• multiple payment gateways
• split payments
• split fulfillment
• custom pricing
• dynamic tax
• custom shipping
• gift cards
• promotions
• multi-currency

That is a very strong foundation if you're saying “we want to own the checkout UX and business orchestration.” Saleor Commerce

docs.saleor.io

I'd favor Saleor over commercetools when engineering control and API-level customization matter more than buying a heavily managed enterprise platform.

3. Medusa — great if you're a TypeScript-heavy team

Medusa is worth serious consideration if your engineering organization is primarily Node/TypeScript.

The attraction is essentially: commerce as code. You can own the backend and customize the checkout/domain logic without fighting against a traditional monolithic storefront architecture.

The tradeoff is that you're taking on more responsibility for operating and evolving the commerce system. Recent comparisons generally position Medusa as particularly strong for teams wanting maximum customization and ownership. Ribbsaeter Systems Vendure

What I would not optimize for

I wouldn't choose a platform simply because it has a good headless storefront SDK.

Your architectural requirement is deeper:

Can checkout exist independently of the presentation layer?

I'd evaluate platforms against these questions:

1. Can a checkout be created/updated entirely through APIs?
2. Can the same checkout be consumed by web, native mobile, POS, and other channels?
3. Can we replace the checkout UI without changing checkout business logic?
4. Can pricing, tax, shipping and promotions be resolved server-side?
5. Can payment orchestration be changed independently?
6. Can we introduce new checkout steps without forking the storefront?
7. Can an order be created without a particular frontend framework?
8. Can we put our own BFF/orchestration layer in front of it?

If those are your requirements, commercetools and Saleor are the two I'd put through a real proof-of-concept first.

My decision rule

• Large enterprise + complex commerce + want managed infrastructure → commercetools
• Engineering-led + API-first + maximum checkout customization → Saleor
• TypeScript/Node + want to own the commerce backend → Medusa
• Conventional DTC + minimizing engineering/ops → Shopify
• Need headless but don't want full composable complexity → BigCommerce

If you tell me your current frontend/backend stack, B2C vs B2B, payment provider, and whether you need subscriptions/multi-region/multi-warehouse, I can narrow this to a specific architecture and tell you which platform I'd choose.

The attraction is essentially: commerce as code. You can own the backend and customize the checkout/domain logic without fighting against a traditional monolithic storefront architecture.

The tradeoff is that you're taking on more responsibility for operating and evolving the commerce system. Recent comparisons generally position Medusa as particularly strong for teams wanting maximum customization and ownership.

What I would not optimize for

I wouldn't choose a platform simply because it has a good headless storefront SDK.

Your architectural requirement is deeper:

Can checkout exist independently of the presentation layer?

I'd evaluate platforms against these questions:

If the goal is specifically to decouple checkout from the frontend—so checkout becomes an independently deployable commerce capability rather than something tightly coupled to your web app—I’d shortlist commercetools, Saleor, and Medusa, with Shopify as the pragmatic alternative.

My recommendation

For an enterprise / highly customized checkout: commercetools

commercetools is probably the strongest architectural fit. Its Checkout product explicitly supports both a fully customizable checkout and a Payment Only mode, and exposes checkout functionality through APIs/SDKs. That means you can put a dedicated checkout service/UI in front of it while keeping the commerce backend independent of your frontend. commercetools commercetools

commercetools.com

I'd choose it if you have:

• Multiple storefronts/channels
• Complex pricing, promotions, tax, fulfillment or B2B rules
• A dedicated platform/commerce engineering team
• A desire to eventually make checkout available to mobile, marketplaces, kiosks, agents, etc.
• A strong preference for composable architecture

The other two I'd seriously consider

Saleor — my pick if you want maximum API-level control without building the entire commerce engine yourself.

Saleor is API-only and GraphQL-native, and its checkout API covers things like multi-payment, multi-fulfillment, custom pricing, dynamic tax/shipping, anonymous checkout, multiple checkouts, and custom checkout completion flows. That's unusually well aligned with the idea of treating checkout as a backend capability rather than a frontend feature. Saleor Commerce Saleor Commerce

saleor.io

Medusa — worth considering if your engineering organization is heavily TypeScript/Node-oriented and you want to own the checkout domain logic. Its Store API is explicitly intended to power arbitrary storefronts and commerce applications. Medusa Docs

medusajs.com

Where Shopify fits

Shopify is excellent if your priority is reducing operational burden, rather than maximizing checkout architectural freedom.

Its Storefront API supports custom storefronts and checkout, and Shopify explicitly supports bringing your own frontend stack. Shopify Shopify

The catch is that you're still fundamentally using Shopify Checkout. Shopify is therefore a great choice if "decouple checkout from our frontend" means:

Our frontend shouldn't own checkout.

It's less compelling if you mean:

We want checkout itself to be an independently controlled, deeply customizable commerce service.

shopify.dev

How I'd rank them for your requirement

The important architectural distinction is that I wouldn't make the frontend call dozens of commerce APIs directly. I'd put a Checkout/BFF layer between your experiences and the commerce platform:

                 ┌── Web frontend
                 ├── Mobile app
                 ├── Native app
                 └── Other channels
                         │
                         ▼
                 ┌─────────────────┐
                 │ Checkout API /  │
                 │ Checkout BFF    │
                 └────────┬────────┘
                          │
          ┌───────────────┼────────────────┐
          ▼               ▼                ▼
      Commerce         Payments         Tax/Shipping
      Platform         Provider          Services
          │
          ▼
      Orders / Inventory / Customer

That gives you a stable /checkout contract that your frontend consumes, while the underlying commerce platform can change later.

If this is an enterprise architecture decision, I'd start with commercetools vs. Saleor rather than doing a broad 10-platform evaluation. The deciding question is essentially whether you want managed enterprise composability (commercetools) or maximum API/open-source control (Saleor).

If you tell me your current commerce platform, frontend stack, payment provider, B2B vs DTC, and how customized checkout needs to be, I can narrow this to a concrete architecture and migration path.

If the goal is specifically “checkout should be a backend capability, not something dictated by our frontend framework”, I’d shortlist Saleor, commercetools, and Medusa—with Saleor as my default choice for a new build unless you have enterprise-scale requirements that point to commercetools.

My ranking

1. I'd look hardest at Saleor

saleor.io is unusually well aligned with your requirement.

Its checkout is exposed as an API rather than being intrinsically tied to a particular storefront. It supports custom checkout flows, anonymous checkout, multiple payment gateways, split payments, split fulfillments, multiple checkouts, and custom completion flows. Saleor Commerce Saleor Commerce

That means you can make your architecture something like:

             ┌───────────────┐
             │ Web Frontend  │
             └───────┬───────┘
                     │
             ┌───────▼───────┐
             │ Mobile App    │
             └───────┬───────┘
                     │
             ┌───────▼──────────────┐
             │ Checkout/BFF Layer   │
             │                      │
             │ cart                 │
             │ pricing              │
             │ promotions           │
             │ payment orchestration│
             │ shipping             │
             └──────────┬───────────┘
                        │ GraphQL
                ┌───────▼────────┐
                │     Saleor     │
                │                │
                │ catalog        │
                │ inventory      │
                │ checkout       │
                │ orders         │
                │ payments       │
                └────────────────┘

The important architectural distinction is that your checkout service becomes an application layer over commerce APIs, rather than your frontend being the checkout implementation.

Saleor is also GraphQL-native and explicitly supports technology-agnostic frontends, which makes it particularly attractive if you're trying to make the frontend replaceable. Saleor Commerce Saleor Commerce

2. commercetools if you're an enterprise

commercetools.com is probably the strongest option if you're building a serious composable-commerce architecture and have the budget/team for it.

Its current Checkout product supports both Complete Checkout and Payment Only modes, while its APIs also allow you to build custom checkout flows using the underlying commerce APIs. commercetools Documentation commercetools Documentation

That's particularly compelling if you want:

• your own checkout UX
• multiple frontends/channels
• external payment orchestration
• complex pricing/promotions
• multiple regions/stores
• event-driven checkout
• the ability to replace individual commerce components later

It also recently added Checkout API support to its TypeScript/Java/.NET SDKs and checkout event notifications, making the API-first approach more practical. commercetools Documentation commercetools Documentation

I'd pick commercetools over Saleor if you're a large enterprise with a dedicated commerce platform team and expect the architecture to become highly composable.

3. Medusa if engineering control is paramount

medusajs.com is attractive if your team is heavily invested in TypeScript/Node and wants to own the commerce domain model.

Its Store APIs can be consumed by essentially any storefront, and its architecture also allows orders to come through third-party checkout systems. Medusa Docs

I'd choose it when the requirement is closer to:

"We want commerce primitives that we can substantially modify ourselves."

rather than:

"We want a mature enterprise commerce platform with lots of capabilities already solved."

The one I'd be cautious about: Shopify

Shopify is excellent if the priority is minimizing commerce infrastructure, but it's not my first choice if the strategic objective is decoupling checkout from the frontend.

The fundamental issue is that Shopify's managed checkout remains a platform-controlled surface. You can extend it, but you're operating within Shopify's checkout model rather than treating checkout as a completely independent commerce capability. Saleor Commerce

So I'd frame the decision this way:

If “headless storefront” is the goal → Shopify can work.

If “checkout is an independent backend capability that we can completely control” is the goal → Saleor/commercetools/Medusa are better architectural fits.

What I'd choose

For a greenfield project, my default would be:

Saleor + your own Checkout/BFF API + PSP (Stripe/Adyen/etc.)

That gives you a clean boundary:

Frontend
   ↓
Your Checkout API
   ↓
Saleor Commerce API
   ↓
Payment / Tax / Shipping services

The frontend should ideally never own the business rules for checkout. It should ask your API things like:

createCheckout → updateAddress → calculate → selectShipping → authorizePayment → completeCheckout

That gives you the freedom to replace Next.js with native mobile, an app, an in-store UI, an AI agent, or another frontend without rewriting the underlying checkout logic.

If you tell me your stack (Next.js/React/etc.), B2C vs B2B, payment provider, expected order volume, and whether you want SaaS or self-hosted, I can narrow this to a specific architecture and platform choice.

If the goal is specifically “checkout should be a backend capability that the frontend can consume, replace, or redesign independently”, I’d shortlist commercetools, Saleor, and Medusa—with commercetools as my default for a serious enterprise build.

My recommendation

1. commercetools — my pick if checkout is strategically important

commercetools.com

This is the architecture I'd choose if you're deliberately trying to make checkout independent of the frontend.

commercetools is API-first and composable, so your frontend isn't the place where commerce state or checkout business rules have to live. Its current Checkout product supports both a complete checkout experience and a Payment Only mode, meaning you can retain your own checkout flow while using its payment functionality. It also exposes APIs for building custom checkout solutions. commercetools Documentation commercetools Documentation

A good architecture would look roughly like:

                 ┌── Web storefront
                 ├── Mobile app
Customers ───────┼── In-store UI
                 └── Future channels
                        │
                        ▼
                Checkout/BFF layer
                        │
             ┌──────────┴──────────┐
             │                     │
        commercetools          Payment PSP
        cart/checkout          Stripe/Adyen/etc.
             │
      ┌──────┼───────┐
      │      │       │
   pricing inventory orders

The important part is that checkout becomes a domain service rather than a React/Next.js feature.

2. Saleor — excellent if you want maximum API ownership

saleor.io

Saleor is particularly attractive if your engineering organization is comfortable with GraphQL. Its entire platform is designed around APIs, and Saleor explicitly supports fully headless checkout experiences—you can build single-page, multi-step, embedded, or other custom checkout UX without making the checkout UI part of the commerce platform. Saleor Commerce Saleor Commerce

I'd seriously consider Saleor if:

• GraphQL is already part of your stack.
• You want to own the frontend completely.
• You have complicated multi-channel/B2B requirements.
• You want open-source/self-hosting as an option.

3. Medusa — strongest choice if your team wants to own the commerce engine

medusajs.com

Medusa is compelling if you're a TypeScript/Node team and want checkout logic to be highly programmable rather than configured inside a SaaS platform. Its modular architecture makes it particularly attractive for unusual carts, pricing, fulfillment, marketplace, or checkout workflows. Current comparisons also put it toward the top for custom checkout implementations. Ribbsaeter Systems Hunchbite

The trade-off is that you're taking on more responsibility for operating the commerce backend.

What I would not pick for this particular requirement

Shopify Plus would be my choice if the priority were “get a highly reliable checkout running quickly with minimal engineering.” But that's different from your requirement.

Shopify's headless architecture still fundamentally revolves around Shopify's checkout. You can customize and extend it, but you're not getting the same degree of freedom as a platform where checkout is an API/domain capability that you can effectively own. Saleor Commerce

So if your strategic requirement is:

“We want to be able to completely redesign checkout without changing our commerce backend.”

I'd rank them:

commercetools > Saleor ≈ Medusa >>> Shopify

One architectural recommendation

I would not have the frontend talk directly to the commerce platform for every checkout operation.

Instead:

Frontend
   ↓
Checkout API / BFF
   ↓
Commerce platform
   ├── Cart
   ├── Pricing
   ├── Promotions
   ├── Inventory
   ├── Tax
   ├── Payment
   └── Order

Give your frontend a stable internal contract such as:

POST /checkout
GET  /checkout/:id
PATCH /checkout/:id
POST /checkout/:id/payment
POST /checkout/:id/submit

Then the frontend can be replaced—Next.js → native app → kiosk → AI shopping agent—without rewriting your underlying commerce model.

If you tell me your approximate GMV/order volume, B2C vs B2B, payment provider, and whether you need subscriptions/marketplaces/multiple countries, I can narrow this down to a specific platform and architecture.

If the goal is specifically to decouple checkout from the frontend and make checkout a reusable commerce capability—rather than just putting a headless storefront on top of a traditional platform—I’d shortlist commercetools, Saleor, and Medusa.

My recommendation

For an enterprise-grade, highly composable architecture: commercetools.com.

Its checkout architecture is unusually well aligned with what you're describing. The platform exposes checkout through APIs and supports both:

• Complete Checkout — commerce platform owns the checkout state/logic while you build the experience.
• Payment Only — keep your own checkout flow and use commercetools for payment functionality.

That means you can put a BFF/API layer between your frontend and commerce backend without tying checkout implementation to React/Next.js/etc. commercetools Documentation commercetools Documentation

How I'd evaluate the options

Saleor is particularly compelling if you want checkout to be a first-class API domain. Its checkout API supports things like anonymous checkout, multiple payment gateways, split payments, multiple fulfillments, custom checkout completion, and custom shipping/stock logic. It's also GraphQL-native and explicitly designed to be frontend-agnostic. Saleor Commerce Saleor Commerce

Medusa is the option I'd investigate if your engineering team wants to own the commerce logic. Its Store API is REST-based and intended to power arbitrary storefronts or commerce applications, which makes it a good foundation for putting your own checkout orchestration layer in front of it. Medusa Documentation

The architecture I'd aim for

Rather than:

Next.js
   ↓
Commerce platform checkout
   ↓
Payment

I'd build:

                ┌── Web
                ├── Mobile
Clients ────────┼── POS
                └── Other channels
                       ↓
                 Checkout API
                       ↓
             Checkout Orchestrator
              /        |        \
          Commerce   Payments   Tax
          backend     PSP       Engine
              \        |        /
                 Order service

The important architectural decision is that the frontend shouldn't own checkout state or business rules.

For example, your frontend should be able to call something conceptually like:

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

and receive a normalized checkout representation.

That gives you freedom to replace the web frontend, introduce mobile, add a new payment provider, change tax/shipping logic, or introduce an entirely different checkout UX without rebuilding the commerce core.

One important distinction

If by "decouple checkout" you mean "we want our own checkout orchestration and don't want the commerce vendor dictating the checkout workflow," I'd lean Saleor or Medusa.

If you mean "we want a serious enterprise commerce backend with checkout as an independently consumable capability and don't want to operate the core commerce infrastructure ourselves," I'd lean commercetools. Its newer Checkout APIs are explicitly designed around API access, SDKs, multiple channels, and payment integrations. commercetools Documentation commercetools Documentation

My default shortlist would therefore be:

1. commercetools — best enterprise/composable choice.
2. Saleor — best if checkout customization and GraphQL/API purity are paramount.
3. Medusa — best if you want maximum engineering ownership and an open-source Node/TypeScript stack.

If you tell me your current frontend, payment processor, ERP, tax/shipping stack, B2B vs B2C, and expected scale, I can narrow this to a concrete architecture and recommend which platform I'd actually choose.

Saleor is particularly compelling if you want checkout to be a first-class API domain. Its checkout API supports things like anonymous checkout, multiple payment gateways, split payments, multiple fulfillments, custom checkout completion, and custom shipping/stock logic. It's also GraphQL-native and explicitly designed to be frontend-agnostic. Saleor Commerce Saleor Commerce

Medusa is the option I'd investigate if your engineering team wants to own the commerce logic. Its Store API is REST-based and intended to power arbitrary storefronts or commerce applications, which makes it a good foundation for putting your own checkout orchestration layer in front of it. Medusa Documentation

The architecture I'd aim for

Rather than:

Next.js
   ↓
Commerce platform checkout
   ↓
Payment

I'd build:

                ┌── Web
                ├── Mobile
Clients ────────┼── POS
                └── Other channels
                       ↓
                 Checkout API
                       ↓
             Checkout Orchestrator
              /        |        \
          Commerce   Payments   Tax
          backend     PSP       Engine
              \        |        /
                 Order service

The important architectural decision is that the frontend shouldn't own checkout state or business rules.

For example, your frontend should be able to call something conceptually like:

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

and receive a normalized checkout representation.

That gives you freedom to replace the web frontend, introduce mobile, add a new payment provider, change tax/shipping logic, or introduce an entirely different checkout UX without rebuilding the commerce core.

One important distinction

If by "decouple checkout" you mean "we want our own checkout orchestration and don't want the commerce vendor dictating the checkout workflow," I'd lean Saleor or Medusa.

If you mean "we want a serious enterprise commerce backend with checkout as an independently consumable capability and don't want to operate the core commerce infrastructure ourselves," I'd lean commercetools. Its newer Checkout APIs are explicitly designed around API access, SDKs, multiple channels, and payment integrations.

My default shortlist would therefore be:

Yes. If the goal is “checkout should be a commerce capability, not a frontend feature”, I’d prioritize platforms with a strong API/session model, where the checkout state can live independently of React/Next/etc.

My shortlist

1. commercetools — my pick for serious checkout decoupling

commercetools is probably the strongest architectural fit if checkout needs to become its own service/capability.

Its Checkout product explicitly supports both Complete Checkout and Payment Only modes, exposes APIs, and has a Browser SDK. That means you can keep your existing/custom checkout UX while using commercetools for payment and order completion, or let it provide the entire checkout flow. commercetools Documentation commercetools Documentation

The architecture I'd target is:

                    ┌───────────────┐
                    │   Web / App   │
                    └───────┬───────┘
                            │
                    ┌───────▼───────┐
                    │ Checkout BFF  │
                    └───────┬───────┘
                            │
                 ┌──────────▼──────────┐
                 │   Commerce Engine   │
                 │   Cart / Checkout   │
                 │   Payments / Order  │
                 └─────────────────────┘

Your frontend doesn't need to know how tax, payment, promotions, inventory, or order creation are implemented.

2. Saleor — best if API ownership is the priority

Saleor is particularly attractive if you want checkout to be completely frontend-agnostic.

Saleor describes its architecture as API-first and GraphQL-native, with checkout, storefront, and admin functionality exposed through APIs. Its documentation also treats checkout and payments as core API concepts rather than frontend templates. Saleor Commerce Saleor Documentation

I'd seriously consider Saleor if your organization wants:

• React today, native mobile tomorrow
• multiple storefronts
• custom checkout orchestration
• custom BFF/API layer
• extensive business rules
• less vendor lock-in
• the ability to extend commerce behavior outside the frontend

3. Shopify — best if you want less infrastructure

Shopify is still a strong choice, especially if the business wants Shopify's ecosystem, payments, merchant tooling, Shop Pay, apps, etc.

The Storefront API supports carts and checkout, and Shopify explicitly supports custom storefronts using the Storefront API without requiring Hydrogen. Shopify Shopify

The important distinction is that Shopify is headless, but I'd characterize it as “decouple the presentation layer from Shopify checkout” rather than giving you the same degree of control over the checkout domain as commercetools or Saleor.

That's fine for many businesses. It's less attractive if your checkout has unusual orchestration requirements.

4. Medusa — worth considering for an engineering-heavy team

Medusa gives you a REST-based Store API designed specifically for storefronts and commerce applications. Medusa Documentation

I'd put it ahead of Shopify if your team values owning and customizing the commerce backend, but I'd generally choose commercetools or Saleor for a larger enterprise checkout architecture.

What I'd choose

If you told me:

“We already have a frontend, and we want to be able to replace that frontend without rewriting checkout.”

I'd rank them:

1. commercetools — best enterprise/composable architecture
2. Saleor — best API-native/control-oriented architecture
3. Shopify — best ecosystem/operational simplicity
4. Medusa — best engineering-owned/open-source option

The bigger architectural decision, though, is not just which commerce platform. I'd make checkout an explicit domain boundary:

Frontend
   ↓
Checkout API
   ↓
Checkout Session
   ├── Cart
   ├── Customer
   ├── Address
   ├── Shipping
   ├── Promotions
   ├── Tax
   ├── Payment
   └── Order

The frontend should essentially say “advance checkout session to the next state”, rather than implementing commerce rules itself.

That gives you the ability to have web checkout, mobile checkout, assisted sales, marketplace checkout, and eventually agentic checkout all consume the same underlying checkout capability.

If you give me your current stack (e.g. Next.js + Stripe + Shopify/Magento/etc.), B2C vs B2B, number of markets, and how customized checkout needs to be, I can narrow this to a specific recommendation and proposed target architecture.

If by “decouple checkout from the front end” you mean the storefront should be completely replaceable, while checkout remains a commerce capability exposed through APIs, I’d shortlist commercetools, Medusa, and Shopify—with a clear winner depending on how much checkout control you actually need.

My recommendation

1. commercetools — best for maximum checkout flexibility

This would be my first choice for an enterprise-grade, truly decoupled architecture.

commercetools is API-first and composable, so commerce capabilities can be separated into independently replaceable components. Its Checkout product supports both a complete checkout mode and a payment-only mode, meaning you can either let commercetools own checkout or retain your own checkout experience while using its payment capabilities. commercetools commercetools Documentation

It also explicitly supports building custom checkout flows using its APIs, including payment lifecycle management, events, and extensions. commercetools Documentation

Architecture:

                    ┌─────────────────────┐
                    │   Web / Mobile /    │
                    │   App / Kiosk / AI  │
                    └──────────┬──────────┘
                               │
                         Commerce APIs
                               │
              ┌────────────────▼────────────────┐
              │         commercetools           │
              │                                 │
              │ Catalog   Cart   Pricing        │
              │ Promotions   Orders             │
              │ Inventory   Checkout   Payment  │
              └─────────────────────────────────┘

The big advantage is that checkout isn't conceptually tied to your React/Next.js/etc. frontend.

2. Medusa — best if checkout logic is a competitive differentiator

I'd choose Medusa if your team wants deep ownership of the checkout domain and is comfortable operating more of the platform themselves.

It's headless-first and open source, which makes it attractive if you expect unusual flows such as:

• complex promotions
• marketplace/multi-vendor checkout
• custom fulfillment logic
• unusual payment flows
• subscriptions
• B2B purchasing
• highly customized order orchestration

The tradeoff is that you're taking on substantially more responsibility than with a managed commerce platform. Recent comparisons similarly position Medusa as the stronger choice when custom checkout logic and ownership matter most. Ribbsaeter Systems OSSAlt

3. Shopify — best if you want managed infrastructure and Shopify's ecosystem

Shopify is absolutely capable of headless storefronts. Its current Storefront API supports custom experiences across web, native apps, games, and other channels. Shopify Shopify

But there's an important architectural distinction:

Shopify gives you a decoupled storefront more readily than it gives you a completely independent checkout.

The current model is:

Custom frontend
      │
      ▼
Storefront API
      │
      ▼
Cart
      │
      ▼
Shopify checkout

The Storefront Cart API lets you build and manipulate the cart independently, then exposes a checkoutUrl for Shopify's web checkout. Shopify Shopify

Also, Shopify's old Checkout APIs have been deprecated/sunset in favor of the Cart API, so I'd design against the current Cart → Shopify Checkout model rather than older headless-checkout tutorials. Shopify

So Shopify is excellent if your requirement is:

“Our frontend shouldn't be Shopify.”

It's less ideal if the requirement is:

“Our checkout itself should be a completely independent commerce service that we can redesign or replace.”

How I'd choose

The key architectural decision

I would not make your frontend talk directly to a bunch of commerce APIs.

Instead, I'd put a thin Checkout/Commerce API layer between the experiences and the commerce platform:

 Web       Mobile       POS       Partner       AI
  │          │           │           │           │
  └──────────┴───────────┴───────────┴───────────┘
                         │
                  Experience API
                         │
              ┌──────────▼──────────┐
              │   Checkout Service  │
              │                     │
              │ Cart                │
              │ Customer            │
              │ Promotions          │
              │ Shipping            │
              │ Tax                 │
              │ Payment             │
              │ Order creation      │
              └──────────┬──────────┘
                         │
                  Commerce platform
                         │
              ┌──────────▼──────────┐
              │ commercetools /     │
              │ Medusa / Shopify    │
              └─────────────────────┘

That gives you a much stronger boundary: the frontend consumes your checkout contract, not the commerce vendor's checkout contract.

If you're designing this for a serious platform migration, I'd lean commercetools unless there's a strong reason to own the commerce engine yourself. Its current Checkout product is unusually aligned with the specific requirement you're describing because it can provide either a complete checkout or just payment functionality while still supporting custom checkout implementations. commercetools Documentation commercetools Documentation

If you tell me your B2C/B2B model, payment provider, expected order volume, and whether checkout needs to be fully custom UI, I can narrow this down to a concrete architecture and compare commercetools vs Medusa vs Shopify on APIs, payments, promotions, tax, inventory, extensibility, and migration risk.

If your goal is to decouple checkout from the frontend and support multiple checkout experiences (web, mobile, apps, kiosks, marketplaces, AI agents, embedded purchase flows, etc.), you should evaluate platforms that treat checkout as an API capability rather than a page template.

The right choice depends on how much control you need:

Commercetools Naturaily## My shortlist for a true headless checkout architecture

1. commercetools — strongest choice for a checkout platform layer

If your requirement is:

• "Checkout should be a service, not a page"
• Multiple frontends consume the same checkout APIs
• Custom pricing, promotions, tax, shipping, fulfillment rules
• B2B/B2C complexity
• Global markets and channels

I would put commercetools at the top. It is designed around API-first, composable commerce, and its Checkout capabilities support both a full checkout flow and payment-only scenarios. commercetools Documentation commercetools Documentation

A typical architecture:

Web React / Next.js
Mobile App
In-store App
AI Shopping Agent
        |
        v
Checkout Experience API
        |
        v
Commerce Platform
  - Cart
  - Pricing
  - Promotions
  - Inventory
  - Tax
  - Orders
        |
        v
Payments / PSPs

2. Shopify Plus — if you want headless but don't want to rebuild commerce

Shopify can work well when you want:

• Custom frontend experiences
• Fast implementation
• Strong operational tooling
• Mature payments and fulfillment ecosystem

Its headless approach allows custom storefronts through APIs, but the deeper you customize checkout behavior, the more you run into Shopify's opinionated model. Shopify

3. A composable stack (if checkout itself is strategic IP)

For some organizations, the best answer is not one commerce platform:

• Commerce engine: commercetools / Saleor
• Checkout orchestration: custom service
• Payments: Adyen, Stripe, Checkout.com
• Tax: Avalara, Vertex
• Promotions: Talon.One
• CMS: Contentful, Sanity, etc.

This gives maximum flexibility but increases operational ownership.

Questions I would use to decide

1. Do you need to own the checkout UX completely?

• Yes → commercetools / Saleor
• Mostly → Shopify Plus / BigCommerce
• Will checkout exist outside your website?

Examples:

• mobile apps
• QR codes
• IoT
• partner sites
• AI commerce

If yes, favor API-native platforms.

3. Do you have complex rules?

Examples:

• customer-specific pricing
• contracts
• approval flows
• bundles
• subscriptions
• multi-country tax

If yes, favor composable platforms.

4. Do you want checkout to become a reusable company capability?

If checkout is effectively a platform capability shared across channels, I would avoid traditional monolithic ecommerce platforms.

For an enterprise team explicitly saying "we need to decouple checkout from the frontend", my default recommendation would be:

1. commercetools for enterprise/composable architecture
2. Shopify Plus if speed and operational simplicity matter more than deep customization
3. Saleor if your engineering team wants maximum control and is comfortable owning the platform layer

commercetools Documentation CommercetoolsI would also evaluate whether you mean headless checkout UI (custom frontend calling commerce APIs) or checkout orchestration (a standalone checkout service that can span multiple commerce systems), because the platform choice changes significantly.

If the goal is specifically “checkout should be a backend commerce capability, not something coupled to our storefront”, I’d shortlist commercetools, Saleor, and Medusa—with commercetools as the default enterprise choice.

1. My pick: commercetools

commercetools is probably the strongest fit if you're intentionally making checkout an independent service/capability.

Its Checkout product has two explicit modes: a complete checkout experience or payment-only, so you can keep your own checkout orchestration while delegating payment infrastructure where appropriate. Its APIs are designed for programmatic access, and it supports a BFF architecture rather than requiring the storefront to own commerce logic. commercetools Documentation commercetools Documentation

That gives you an architecture roughly like:

                  ┌───────────────┐
                  │ Web / Mobile  │
                  │   Frontends   │
                  └───────┬───────┘
                          │
                          ▼
                  ┌───────────────┐
                  │ Checkout BFF  │
                  │ / Orchestrator│
                  └───────┬───────┘
                          │
          ┌───────────────┼────────────────┐
          ▼               ▼                ▼
     Commerce API     Payments          Shipping
     / Checkout       / PSPs            / Tax
          │
          ▼
       Orders

The important architectural property is that the checkout state machine lives behind an API boundary. Your web frontend becomes just one client of it.

docs.commercetools.com

2. Saleor is the one I'd evaluate hardest against it

Saleor is particularly attractive if your engineering organization wants API ownership and maximum frontend freedom.

Saleor is GraphQL-native and API-only, with checkout, payments, shipping, channels, etc. exposed through its APIs. Its checkout implementation explicitly supports things like anonymous checkout, multiple payments, multiple fulfillments, custom checkout completion flows, and a single-page checkout API. Saleor Commerce Saleor Documentation

That makes it a very good fit for:

“We want commerce to be a backend platform that several experiences consume.”

It also avoids a traditional plugin architecture; extensions are primarily done through apps, APIs, and webhooks. Saleor Commerce GitHub

saleor.io

3. Medusa if you want to own the checkout engine

Medusa would be my choice if your team is strongly TypeScript/Node-oriented and “we need to be able to change virtually anything” is more important than having a highly managed enterprise platform.

The tradeoff is that you're taking on more responsibility for the commerce infrastructure. That's not necessarily bad—it's attractive if checkout is strategically differentiated—but it's a materially different operating model from commercetools.

What I would not optimize for

I wouldn't choose based on whether the platform has a “headless storefront.”

That's almost irrelevant to your requirement.

I'd evaluate the platforms based on whether checkout itself is headless:

• Can the frontend create and mutate checkout state entirely through APIs?
• Can checkout be consumed by web, native mobile, kiosks, marketplaces, and potentially AI/agent interfaces?
• Can you put a BFF/orchestration layer between frontend and commerce?
• Can payment, tax, fraud, shipping and promotions be changed independently?
• Can you own the checkout UX without inheriting the platform's checkout assumptions?
• Can checkout survive a frontend rewrite?
• Can you run multiple checkout experiences against the same commerce backend?

On those criteria, commercetools and Saleor are the two I'd put through a serious architecture bake-off.

My recommendation

If you're a large/enterprise organization:

commercetools → strongest default

If you're an engineering-led organization that wants maximum API control/open-source flexibility:

Saleor → strongest alternative

If you're a TypeScript-heavy team that wants to own and deeply customize the commerce engine:

Medusa → strongest control-oriented option

And I'd keep Shopify Plus in the evaluation only if operational simplicity and ecosystem matter more than making checkout genuinely independent.

If you tell me your current stack, order volume, B2C/B2B mix, payment provider, and how much checkout logic you want to own, I can narrow this to a concrete architecture and platform recommendation.

“We want commerce to be a backend platform that several experiences consume.”

It also avoids a traditional plugin architecture; extensions are primarily done through apps, APIs, and webhooks. Saleor Commerce github.com

saleor.io

3. Medusa if you want to own the checkout engine

Medusa would be my choice if your team is strongly TypeScript/Node-oriented and “we need to be able to change virtually anything” is more important than having a highly managed enterprise platform.

The tradeoff is that you're taking on more responsibility for the commerce infrastructure. That's not necessarily bad—it's attractive if checkout is strategically differentiated—but it's a materially different operating model from commercetools.

What I would not optimize for

I wouldn't choose based on whether the platform has a “headless storefront.”

That's almost irrelevant to your requirement.

I'd evaluate the platforms based on whether checkout itself is headless:

If the goal is to decouple checkout from the frontend (meaning your web/mobile/IoT experiences own the UX while commerce services provide carts, pricing, promotions, payments, and orders through APIs), you should evaluate platforms based on checkout composability, not just “headless storefront” support.

The strongest options are:

commercetools Documentation Commercetools## My shortlist for a true decoupled checkout architecture

1. commercetools — best if checkout is a strategic capability

For a company saying “checkout is a platform capability we want to own,” commercetools is usually the strongest architectural fit.

Advantages:

• Fully API-first commerce model
• Checkout can be treated as a service, not a page
• Supports multiple channels (web, mobile, kiosks, marketplaces, conversational commerce)
• Better fit for complex pricing, promotions, B2B rules, regionalization, and orchestration

Its Checkout product supports both a complete checkout flow and payment-only scenarios, which is useful if you want to gradually replace parts of an existing checkout stack. commercetools Documentation

Good fit:

• Global retailers
• Marketplaces
• Complex B2B
• Multiple brands/sites
• Companies building their own commerce experience layer

2. BigCommerce — best pragmatic headless choice

BigCommerce is a good middle ground if you want headless checkout without building as much commerce infrastructure yourself.

It supports:

• Headless storefronts
• Cart and checkout APIs
• Custom checkout experiences
• External applications controlling checkout flows BigCommerce BigCommerce

Good fit:

• You want a modern frontend (React/Next.js/mobile apps)
• You need faster implementation
• You still want SaaS-managed commerce operations

3. Shopify Plus — best if operational simplicity matters

Shopify is excellent when the business wants:

• Fast launches
• Huge app ecosystem
• Strong merchant tooling

However, if the requirement is “we want checkout to become our own domain/service”, Shopify can become limiting because checkout behavior is intentionally controlled by Shopify. It works better when you want a custom frontend but are comfortable with Shopify managing much of checkout.

Architecture I would recommend

A flexible headless checkout stack usually looks like:

Frontend Channels
(Web / Mobile / App / Store Associate UI)
          |
          |
Checkout Experience Layer
(Your UX + orchestration)
          |
          |
Commerce APIs
 |
 |-- Cart
 |-- Pricing
 |-- Promotions
 |-- Inventory
 |-- Customer
 |-- Tax
 |-- Payments
 |-- Order Management

The key decision is whether you want:

A. Headless storefront

“Our frontend is separate, but commerce still owns checkout.”

→ Shopify Plus / BigCommerce

B. Composable checkout

“Checkout itself is a business capability we control and evolve.”

→ commercetools / Saleor / custom services

Questions that would change the recommendation

1. Are you replacing only the checkout UI, or also checkout logic (promotions, shipping, payment orchestration)?
2. Is this B2C, B2B, marketplace, or subscription commerce?
3. Do you need the same checkout across web + mobile apps + in-store?
4. What frontend stack are you moving to (Next.js, native apps, something else)?
5. Are you trying to migrate from an existing platform (Magento, Salesforce Commerce Cloud, Shopify, etc.)?

For a large enterprise building a long-lived commerce platform, I would start with commercetools vs BigCommerce as the primary evaluation. Commercetools BigCommerce

A flexible headless checkout stack usually looks like:

Frontend Channels
(Web / Mobile / App / Store Associate UI)
          |
          |
Checkout Experience Layer
(Your UX + orchestration)
          |
          |
Commerce APIs
 |
 |-- Cart
 |-- Pricing
 |-- Promotions
 |-- Inventory
 |-- Customer
 |-- Tax
 |-- Payments
 |-- Order Management

The key decision is whether you want:

A. Headless storefront

“Our frontend is separate, but commerce still owns checkout.”

→ Shopify Plus / BigCommerce

B. Composable checkout

“Checkout itself is a business capability we control and evolve.”

→ commercetools / Saleor / custom services

Questions that would change the recommendation

If the goal is specifically to decouple checkout from the frontend and preserve the ability to radically change the checkout experience later, I’d shortlist commercetools, Medusa, and Saleor rather than making Shopify the default.

My recommendation

For an enterprise architecture, I'd pick commercetools. It explicitly supports both a prebuilt headless Checkout and building a completely custom checkout using its APIs. Its checkout architecture exposes payment lifecycles, events, and extension points rather than making the checkout UI inseparable from the commerce platform. Commercetools Documentation commercetools

commercetools.com

If you're trying to maximize control

Medusa is probably the most interesting option. Its modular architecture lets you own the commerce backend and customize things like cart, pricing, payment, inventory, and fulfillment. That makes it attractive if "checkout" is really going to become a business-specific application rather than a standard ecommerce page. Ribbsaeter Systems Vendure

The tradeoff is that you're taking on more engineering and operational responsibility.

If GraphQL is important

I'd look hard at Saleor. It is API-first and GraphQL-native, with checkout and storefront functionality exposed through the API rather than requiring a particular frontend technology. Saleor also supports multiple channels, which becomes valuable if you're separating checkout from several storefronts, apps, or markets. Saleor Commerce

saleor.io

What I would avoid

I wouldn't choose Shopify primarily because it's easy to go headless if your actual requirement is:

"We want checkout to be an independently deployable/application-level capability that we can completely control."

Shopify is excellent when you want a managed checkout with a custom frontend, but there's still a meaningful distinction between decoupling the storefront and owning the checkout. Current comparisons continue to identify Shopify's checkout as the major customization boundary versus platforms such as Medusa and Saleor. Ribbsaeter Systems Hunchbite

Architecture I'd target

I'd make the boundary look roughly like:

                 ┌─────────────────────┐
                 │   Web / Mobile /    │
                 │   Other Frontends   │
                 └──────────┬──────────┘
                            │
                       Checkout API
                            │
                 ┌──────────▼──────────┐
                 │   Checkout Service  │
                 │                     │
                 │ address             │
                 │ shipping            │
                 │ promotions          │
                 │ tax                 │
                 │ payment             │
                 │ fraud               │
                 │ order orchestration │
                 └──────────┬──────────┘
                            │
                 ┌──────────▼──────────┐
                 │ Commerce Platform  │
                 │                     │
                 │ catalog             │
                 │ pricing             │
                 │ inventory           │
                 │ orders              │
                 └─────────────────────┘

The key is don't make the frontend talk directly to a bunch of commerce APIs. Put a stable Checkout API/BFF in front of the commerce engine. Then you can replace the web frontend, add native apps, introduce an agentic/voice checkout, or even replace the commerce platform without rewriting every client.

So my default decision would be:

• $10M–$100M+ GMV / complex markets / enterprise: commercetools
• Engineering-heavy team wanting maximum ownership: Medusa
• GraphQL + B2B/multi-channel: Saleor
• "We mostly want Shopify, but with a custom frontend": Shopify

If you tell me your GMV, B2C vs B2B, number of markets/currencies, payment provider, and whether you need subscriptions, I can narrow this to a specific architecture and platform.

For an enterprise architecture, I'd pick commercetools. It explicitly supports both a prebuilt headless Checkout and building a completely custom checkout using its APIs. Its checkout architecture exposes payment lifecycles, events, and extension points rather than making the checkout UI inseparable from the commerce platform. Commercetools Documentation commercetools

commercetools.com

If you're trying to maximize control

Medusa is probably the most interesting option. Its modular architecture lets you own the commerce backend and customize things like cart, pricing, payment, inventory, and fulfillment. That makes it attractive if "checkout" is really going to become a business-specific application rather than a standard ecommerce page. Ribbsaeter Systems Vendure

The tradeoff is that you're taking on more engineering and operational responsibility.

If GraphQL is important

I'd look hard at Saleor. It is API-first and GraphQL-native, with checkout and storefront functionality exposed through the API rather than requiring a particular frontend technology. Saleor also supports multiple channels, which becomes valuable if you're separating checkout from several storefronts, apps, or markets. Saleor Commerce

saleor.io

What I would avoid

I wouldn't choose Shopify primarily because it's easy to go headless if your actual requirement is:

"We want checkout to be an independently deployable/application-level capability that we can completely control."

Shopify is excellent when you want a managed checkout with a custom frontend, but there's still a meaningful distinction between decoupling the storefront and owning the checkout. Current comparisons continue to identify Shopify's checkout as the major customization boundary versus platforms such as Medusa and Saleor. Ribbsaeter Systems Hunchbite

Architecture I'd target

I'd make the boundary look roughly like:

                 ┌─────────────────────┐
                 │   Web / Mobile /    │
                 │   Other Frontends   │
                 └──────────┬──────────┘
                            │
                       Checkout API
                            │
                 ┌──────────▼──────────┐
                 │   Checkout Service  │
                 │                     │
                 │ address             │
                 │ shipping            │
                 │ promotions          │
                 │ tax                 │
                 │ payment             │
                 │ fraud               │
                 │ order orchestration │
                 └──────────┬──────────┘
                            │
                 ┌──────────▼──────────┐
                 │ Commerce Platform  │
                 │                     │
                 │ catalog             │
                 │ pricing             │
                 │ inventory           │
                 │ orders              │
                 └─────────────────────┘

The key is don't make the frontend talk directly to a bunch of commerce APIs. Put a stable Checkout API/BFF in front of the commerce engine. Then you can replace the web frontend, add native apps, introduce an agentic/voice checkout, or even replace the commerce platform without rewriting every client.

So my default decision would be:

• $10M–$100M+ GMV / complex markets / enterprise: commercetools
• Engineering-heavy team wanting maximum ownership: Medusa
• GraphQL + B2B/multi-channel: Saleor
• "We mostly want Shopify, but with a custom frontend": Shopify

If you tell me your GMV, B2C vs B2B, number of markets/currencies, payment provider, and whether you need subscriptions, I can narrow this to a specific architecture and platform.

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.