Neutral mentions of BigCommerce

If speed-to-launch is the overriding constraint, I’d shortlist Shopify + Hydrogen and BigCommerce + Catalyst rather than jumping straight to a fully composable stack.

My ranking for a mid-size retailer

1. Shopify + Hydrogen — best overall for speed

• Shopify handles the commerce backend, checkout, payments, catalog, orders, etc.
• Hydrogen gives you a React-based headless storefront with prebuilt Shopify-specific components, utilities, and tooling. Shopify also provides Oxygen hosting. Shopify Shopify
• Shopify specifically positions Hydrogen as a way to accelerate a headless build rather than starting from a blank React application. Shopify
• I'd choose this if: you're primarily DTC, want a relatively small engineering footprint, and don't have unusually complex commerce requirements.
• BigCommerce + Catalyst — best if you need more backend flexibility

• Catalyst is a Next.js/React headless storefront with a GraphQL Storefront API and a production-ready B2C funnel, so you're not building basic commerce functionality yourself. BigCommerce
• BigCommerce explicitly supports headless starter solutions and positions Catalyst as its fast-track implementation path. BigCommerce BigCommerce
• I'd choose this if: you have more complicated catalog/pricing requirements, multiple storefronts, or want less dependence on Shopify's ecosystem.
• commercetools — powerful, but probably wrong for a tight deadline

• It's attractive when you're deliberately building a highly composable architecture, but that flexibility generally means more architecture, integration and implementation work.
• I'd choose it if: you're optimizing for a sophisticated long-term enterprise architecture rather than the fastest credible migration.

What I'd actually do

For a mid-size retailer under serious time pressure, I'd aim for:

Shopify → Hydrogen → existing/selected CMS → existing PIM/search/ERP integrations → Oxygen

rather than trying to make every part of the stack composable on day one.

The important trick is not making the migration itself a giant re-platforming project. Keep the commerce backend and operational systems as stable as possible, replace the customer-facing layer first, and defer architectural cleanup.

If you're already on Shopify, the case is particularly strong: Shopify documents a migration path where carts can remain compatible between the existing storefront and Hydrogen, and checkout remains Shopify-hosted. Shopify

If you're already on BigCommerce, I'd strongly favor Catalyst rather than switching commerce platforms just to go headless.

shopify.dev
docs.bigcommerce.com

If you tell me your current commerce platform, approximate annual GMV, CMS/PIM, and target launch window (e.g. 8 weeks vs. 6 months), I can narrow this down to a specific stack and implementation approach.

If speed to launch is the #1 constraint, I’d narrow it to Shopify Hydrogen and BigCommerce Catalyst rather than starting with a fully custom composable stack.

My ranking for a mid-size retailer

My default choice: Shopify Hydrogen if your commerce backend is already Shopify. Shopify positions Hydrogen/Oxygen specifically as its recommended headless stack, with prebuilt commerce components, CLI tooling, and integrated deployment. Hydrogen Shopify

hydrogen.shopify.dev

BigCommerce Catalyst is probably the strongest alternative if you're on BigCommerce or want a more explicitly composable mid-market setup. Catalyst gives you a working Next.js/React storefront, GraphQL API client, product/search/cart functionality, and hosted checkout rather than making your team assemble those pieces. BigCommerce BigCommerce

catalyst.dev

What I'd do under a tight deadline

Don't build "headless architecture" as a technology project. Build a thin vertical slice:

1. Catalog → PDP → cart → checkout
2. Search/category pages
3. CMS/content
4. Analytics and critical integrations
5. Only then migrate the remaining experience

For a mid-size retailer, I'd specifically avoid starting with commercetools + a separate CMS + search + personalization + custom checkout unless you have requirements that genuinely demand it. The integration surface can eat your schedule.

If you tell me your current commerce platform, CMS, ERP/PIM, and target launch timeframe (e.g. 8 weeks vs. 6 months), I can give you a much more concrete recommendation and a proposed stack.

BigCommerce Catalyst is probably the strongest alternative if you're on BigCommerce or want a more explicitly composable mid-market setup. Catalyst gives you a working Next.js/React storefront, GraphQL API client, product/search/cart functionality, and hosted checkout rather than making your team assemble those pieces.

If your agency’s core offering is custom frontends, I’d make Medusa the default platform you recommend, with Shopify Plus as the managed/SaaS option for clients who prioritize operational simplicity.

My recommendation

Why I'd pick Medusa for an agency

Medusa is particularly well aligned with your business model because the storefront is completely separate from the commerce backend. You can build the frontend in Next.js, Remix, Astro, or essentially whatever stack your agency prefers, and consume Medusa through its Store API and custom APIs. Medusa Docs Medusa Docs

More importantly, Medusa lets a single instance manage multiple stores, although multi-tenancy isn't native in the sense of an enterprise SaaS tenant-management layer—you'd implement the tenant relationships/isolation yourself. Medusa Docs

That distinction matters for an agency:

Client → Tenant → Store/Sales Channel → Products/Pricing/Inventory → Custom Frontend

You can build your own agency "control plane" on top of Medusa rather than forcing every client into the platform's standard storefront model.

It also gives you a lot of room to productize your work: custom checkout, subscriptions, marketplaces, unusual pricing, ERP integrations, custom admin experiences, etc. Medusa explicitly supports custom modules, data models, workflows, API routes, and admin customization. Medusa Docs Medusa Docs

When I'd recommend Shopify Plus instead

For a client saying:

"We want a completely custom frontend, but we don't want our agency maintaining commerce infrastructure."

I'd choose Shopify Plus + custom frontend.

Shopify Plus has a mature multi-store organization model with expansion stores, centralized organization management, and separate storefronts. Shopify Help Center Shopify Help Center

The tradeoff is architectural: those stores are independent data environments. Products, inventory, collections, and settings aren't automatically shared between them. Shopify Help Center

So I wouldn't describe Shopify Plus as a true "multi-tenant commerce backend." It's more like:

Organization → Store A / Store B / Store C → custom frontends

That's fantastic for a brand with regional stores or multiple storefronts, but less ideal if your agency is building a platform where dozens/hundreds of client tenants share a commerce infrastructure.

Saleor is the other one I'd seriously evaluate

If your team likes GraphQL and your clients skew toward B2B, multi-channel, complex catalogs, multiple warehouses, and enterprise requirements, I'd put Saleor very high on the shortlist. Current industry comparisons specifically highlight its GraphQL-first architecture and multi-channel model. Ribbsaeter Systems Naturaily

I'd roughly position the three like this:

• Medusa → "We want to own the architecture and customize everything."
• Shopify Plus → "We want the least operational burden and a proven commerce engine."
• Saleor → "We want an API-first, GraphQL-native commerce platform for sophisticated commerce."

For your agency, I'd standardize the stack

If I were setting up an agency platform today, I'd seriously consider:

Next.js + Medusa + PostgreSQL + Stripe + headless CMS + your own tenant/control plane

Then offer Shopify Plus when the client's requirements make managed SaaS more attractive.

The important thing is that I wouldn't build the commerce engine yourself. Build your agency's differentiation around the frontend, tenant management, integrations, design system, deployment pipeline, and client tooling.

If you tell me roughly how many stores/tenants you expect per deployment (e.g. 10, 100, 1,000+) and whether each tenant needs isolated products/orders/inventory, I can recommend the architecture I'd use for the multi-tenant layer as well.

It also gives you a lot of room to productize your work: custom checkout, subscriptions, marketplaces, unusual pricing, ERP integrations, custom admin experiences, etc. Medusa explicitly supports custom modules, data models, workflows, API routes, and admin customization. Medusa Docs Medusa Docs

When I'd recommend Shopify Plus instead

For a client saying:

"We want a completely custom frontend, but we don't want our agency maintaining commerce infrastructure."

I'd choose Shopify Plus + custom frontend.

Shopify Plus has a mature multi-store organization model with expansion stores, centralized organization management, and separate storefronts. Shopify Help Center Shopify Help Center

The tradeoff is architectural: those stores are independent data environments. Products, inventory, collections, and settings aren't automatically shared between them. Shopify Help Center

So I wouldn't describe Shopify Plus as a true "multi-tenant commerce backend." It's more like:

Organization → Store A / Store B / Store C → custom frontends

That's fantastic for a brand with regional stores or multiple storefronts, but less ideal if your agency is building a platform where dozens/hundreds of client tenants share a commerce infrastructure.

Saleor is the other one I'd seriously evaluate

If your team likes GraphQL and your clients skew toward B2B, multi-channel, complex catalogs, multiple warehouses, and enterprise requirements, I'd put Saleor very high on the shortlist. Current industry comparisons specifically highlight its GraphQL-first architecture and multi-channel model.

I'd roughly position the three like this:

For a startup with limited funding, I’d put Medusa at the top of the list—especially if you have a capable JavaScript/TypeScript developer or agency.

My ranking

🥇 Best overall: Medusa

medusajs.com is particularly attractive because its commerce engine is open source, there are no GMV/platform fees, and its managed Cloud starts at $29/month, with a production-oriented Launch tier starting at $99/month. Medusa Medusa Docs

You get a surprisingly complete foundation: products, orders, customers, sales channels, regions/currencies, promotions, payments, fulfillment, and a modular architecture that you can customize rather than fighting against. Medusa's current Cloud pricing explicitly lists unlimited products, orders, sales channels, regions and currencies without additional commerce-feature fees. Medusa Docs

Why I'd choose it for a funded-but-budget-conscious startup:

• Very low initial software cost.
• You retain considerable control over the backend.
• Excellent fit with a Next.js/React storefront.
• No percentage-of-GMV platform fee.
• You can start on inexpensive infrastructure and scale later.
• Custom business logic is much easier than on traditional SaaS platforms.

The catch is that you are taking on more engineering responsibility than with Shopify.

🥈 Shopify + Hydrogen if engineering resources are scarce

If "limited funding" also means limited developer time, I'd actually choose Shopify.

Shopify gives you the mature commerce backend, checkout, payments, inventory, apps, and operational tooling, while Hydrogen lets you build a custom headless storefront. The tradeoff is recurring Shopify cost and less control over the underlying commerce engine.

So I'd use this rule:

Limited money + strong developers → Medusa.
Limited money + limited developers → Shopify.

🥉 Saleor if you already know you'll need sophisticated commerce

saleor.io is technically excellent, particularly for GraphQL-first development, international commerce, B2B, and complex catalogs. But its managed Cloud is dramatically more expensive: the current Select tier starts at $1,599/month, while the higher-volume tier starts at $3,999/month. Saleor Commerce

That's hard to justify for a cash-constrained startup unless Saleor's capabilities directly solve an important requirement.

What I'd actually do

For a typical startup launching a new DTC brand, I'd build:

Next.js storefront → Medusa → PostgreSQL → Stripe → managed hosting/CDN

Start around the lowest practical infrastructure cost, validate product-market fit, and only introduce more specialized infrastructure as traffic and requirements justify it.

One important caveat: headless itself costs engineering money. A 2026 comparison estimates headless implementations commonly have substantially higher development costs than conventional Shopify/WooCommerce setups. Teamz Lab If your storefront doesn't genuinely need a highly customized experience, a conventional Shopify store can be the financially smarter startup choice.

Bottom line: Medusa gives you the best cost/features balance for a technically capable startup; Shopify gives you the best cost/time-to-market balance.

For thousands of SKUs plus genuinely complex product models, I’d put commercetools and Elastic Path at the top of the shortlist, with Saleor as the strongest open-source/API-first alternative.

My first choice: commercetools

For an enterprise catalog, commercetools is particularly compelling. Its catalog model separates Products, Variants, Product Types, Categories, Product Selections and Product Projections, giving you considerably more control than a typical SaaS storefront platform. commercetools Documentation commercetools Documentation

More importantly for your use case, its Modular Catalog is now in public beta. Variants can be first-class resources rather than embedded inside Products, with support for up to 10,000 variants per Product versus the classic 100-variant model. That is a meaningful improvement if your SKU structures are unusually large. commercetools Documentation commercetools Documentation

It is also genuinely API-first rather than simply putting an API in front of a traditional commerce application.

Elastic Path deserves a very close look

If "complex product models" means things like configurable products, B2B assortments, multiple catalogs/price books, bundles, subscriptions, or sophisticated product relationships, I'd evaluate Elastic Path alongside commercetools.

Its Product Experience Manager is explicitly designed around API-first/headless delivery and says it is built to handle thousands of SKUs, catalogs and price books. Elastic Path

A recent 2026 comparison also puts Elastic Path specifically in the category of complex enterprise B2B/configurable commerce, while positioning commercetools as the broader enterprise composable choice. Vendure

When I'd choose Saleor

If you have a strong engineering organization and want GraphQL-native APIs plus much more ownership of the underlying platform, Saleor is interesting. Its storefront and admin are headless/API-driven, with GraphQL and extensive webhooks; its current platform also emphasizes dynamic product models and structured attributes. Saleor Commerce Saleor Commerce

I'd choose it over commercetools if avoiding proprietary platform lock-in and having code-level control are major priorities.

What I'd actually shortlist

For your description, I'd run an RFP/POC with:

1. commercetools — best overall enterprise/composable candidate.
2. Elastic Path — potentially better if your catalog has unusually complex B2B/configuration requirements.
3. Saleor — best challenger if your engineering team favors GraphQL and open source.
4. Adobe Commerce — worth considering if you're already heavily invested in Adobe.
5. BigCommerce — only if your catalog complexity is moderate and operational simplicity matters more than maximum modeling flexibility.

The key thing I'd test isn't simply "how many SKUs can it hold." I'd give each vendor your actual hardest 20–50 product types and test variant inheritance, bundles/configurations, regional assortments, price books, inventory relationships, search/filtering, bulk imports, and API payload/query performance.

If you tell me what makes your product models complex (e.g. 10k variants/SKU families, configurable products, B2B customer-specific catalogs, bundles, technical attributes, regional catalogs, etc.), I can narrow this to the 2–3 platforms I'd seriously consider and explain the architectural tradeoffs.

It is also genuinely API-first rather than simply putting an API in front of a traditional commerce application.

Elastic Path deserves a very close look

If "complex product models" means things like configurable products, B2B assortments, multiple catalogs/price books, bundles, subscriptions, or sophisticated product relationships, I'd evaluate Elastic Path alongside commercetools.

Its Product Experience Manager is explicitly designed around API-first/headless delivery and says it is built to handle thousands of SKUs, catalogs and price books. Elastic Path

A recent 2026 comparison also puts Elastic Path specifically in the category of complex enterprise B2B/configurable commerce, while positioning commercetools as the broader enterprise composable choice. Vendure

When I'd choose Saleor

If you have a strong engineering organization and want GraphQL-native APIs plus much more ownership of the underlying platform, Saleor is interesting. Its storefront and admin are headless/API-driven, with GraphQL and extensive webhooks; its current platform also emphasizes dynamic product models and structured attributes.

I'd choose it over commercetools if avoiding proprietary platform lock-in and having code-level control are major priorities.

What I'd actually shortlist

For your description, I'd run an RFP/POC with:

For an enterprise catalog with thousands of SKUs and genuinely complex product models, I’d shortlist commercetools and Elastic Path first. The better choice depends on whether your complexity is primarily product/variant modeling or B2B catalog, pricing, and assortment rules.

My pick: commercetools

commercetools.com is probably the strongest general-purpose enterprise headless option.

Its catalog model separates Products, Product Types, Variants, Categories, Product Selections, pricing, and search, which gives you a lot of control over complicated schemas. Its newer modular catalog model can support up to 10,000 variants per product, compared with 100 in the classic model. commercetools Documentation commercetools Documentation

It also provides REST APIs plus GraphQL, and the platform is explicitly designed around composable/API-driven commerce. commercetools Documentation commercetools

That's particularly attractive if your architecture looks something like:

ERP/PIM → commerce catalog → search → custom frontend(s) → OMS/fulfillment

rather than expecting the commerce platform to own everything.

Elastic Path is worth serious consideration

elasticpath.com may actually be the better choice if your "complex catalog" means things like:

• thousands/millions of SKUs
• multiple catalogs for different customers/regions
• customer-specific assortments
• complex B2B price books
• bundles/configurable products
• account hierarchies
• contract/volume pricing
• manufacturer/distributor use cases

Elastic Path specifically positions its catalog/PXM around complex B2B catalogs, with multiple catalogs, product attributes, bundles, variations and rules-based pricing. Elastic Path Elastic Path Its catalog architecture also separates products, hierarchies, catalogs and price books, which can be valuable when the same underlying products appear differently across markets or customer groups. Elastic Path

The important distinction

If you mean:

"We have complicated product schemas, lots of attributes, variants, relationships, and need clean APIs for several custom storefronts."

→ commercetools

If you mean:

"We are a manufacturer/distributor with complicated assortments, customer-specific catalogs, pricing, bundles, and B2B purchasing rules."

→ Elastic Path

If you're already deeply invested in SAP ERP/S4HANA, I'd put SAP Commerce Cloud into the evaluation despite its heavier architecture.

One thing I'd not use as the primary selection criterion is simply "how many SKUs can it store." Thousands of SKUs isn't particularly challenging for any of these platforms. The harder question is whether your product model, relationships, pricing, catalog segmentation, search, and APIs remain manageable as the catalog evolves.

If you tell me roughly (1) SKU count, (2) number of attributes/variants per product, (3) B2B vs B2C, (4) whether you have SAP/Oracle/other ERP, and (5) how many storefronts/channels, I can give you a much tighter commercetools vs Elastic Path vs SAP vs BigCommerce recommendation.

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.

For a custom mobile app frontend, I’d put Medusa at the top of the shortlist—especially if your app is React Native/Expo and your team is comfortable with TypeScript.

Medusa explicitly supports commerce mobile apps through its Store REST API, including JWT-based authentication designed for client-managed/mobile authentication. Medusa Docs Medusa Docs

My ranking

1. 🥇 Medusa — my default recommendation

medusajs.com

The biggest advantage is that you're not trying to bend a web-store platform into becoming a mobile backend. Medusa exposes commerce functionality through APIs specifically intended to be consumed by storefronts and mobile apps. Medusa Docs

It's particularly attractive if you need things like:

• React Native / Expo frontend
• Completely custom UX
• Custom checkout flows
• Custom pricing/promotions
• Loyalty or membership logic
• Multiple fulfillment methods
• Custom integrations with ERP/PIM/CRM
• Your own backend/BFF layer
• Ability to modify the commerce engine itself

Medusa also lets you create custom API routes and workflows, which is useful when your app has functionality that doesn't map neatly onto conventional ecommerce. Medusa Docs Medusa Docs

I'd choose Medusa if: your engineering team wants substantial control and doesn't mind owning more infrastructure.

2. 🥈 commercetools — best enterprise choice

commercetools.com

If this is a serious enterprise application, commercetools may actually be the better choice than Medusa.

Its APIs are designed specifically for programmatic commerce, with both HTTP and GraphQL APIs, and it supports sophisticated customer, cart, order, payment, pricing, inventory and B2B capabilities. commercetools Documentation commercetools Documentation

It's particularly strong if your architecture looks like:

                 ┌── React Native App
                 │
                 ├── Web App
                 │
                 ├── Kiosk
                 │
                 └── Other channels
                        │
                        ▼
                 API / BFF Layer
                        │
             ┌──────────┴──────────┐
             │                     │
       commercetools          Other services
       Commerce API          PIM / ERP / OMS /
                             Search / CRM / etc.

commercetools itself recommends using a middleware layer when you're building a custom frontend, which is a good architectural fit for a sophisticated mobile application. commercetools Documentation

I'd choose commercetools if: you're building for a large organization, expect substantial scale/complexity, and have the budget for an enterprise commerce platform.

3. 🥉 Saleor — excellent if you want GraphQL

Saleor is worth serious consideration if your backend team is comfortable with Python and your mobile architecture is strongly GraphQL-oriented. Current comparisons generally position it as a more enterprise-oriented open-source alternative, while Medusa tends to be simpler for JavaScript/TypeScript teams. OSSAlt

What I would actually pick

If you told me:

"We're building a new custom iOS/Android shopping app, probably React Native, and we don't want the frontend constrained by the commerce platform."

I'd choose:

Medusa → React Native/Expo → your own thin BFF/API layer

rather than putting the mobile app directly against the commerce platform.

That gives you:

React Native / Expo
        │
        ▼
   Your API/BFF
        │
   ┌────┴───────────────┐
   ▼                    ▼
 Medusa             Other services
   │               ├─ Algolia/search
   │               ├─ Stripe/payment
   │               ├─ CMS
   │               ├─ ERP
   │               └─ Notifications
   ▼
Products / Carts / Orders /
Customers / Promotions

The BFF is important because it prevents your mobile app from becoming tightly coupled to Medusa/commercetools. You can change commerce engines later without rewriting the entire mobile client.

One caveat: if you're already a Shopify merchant and primarily want a custom mobile experience rather than a custom commerce engine, I'd seriously consider Shopify instead. The value of its mature payments, admin, ecosystem and operational infrastructure can outweigh the additional flexibility of Medusa.

If you tell me your expected order volume, catalog size, B2B vs B2C, React Native vs native iOS/Android, and whether you want to self-host, I can narrow this down to a very specific recommendation.

If your primary requirement is a custom mobile app frontend—iOS/Android built in React Native, Flutter, Swift/Kotlin, etc.—I’d prioritize API quality, checkout flexibility, authentication, webhooks, SDKs, and how much of the commerce backend you need to customize rather than how good the platform’s web storefront is.

My ranking

🥇 My default choice: Medusa

For a new custom mobile app, I'd probably choose Medusa unless you have enterprise-scale requirements.

Medusa is particularly attractive because it's a headless, Node.js/TypeScript commerce engine. Your mobile app can consume the commerce APIs directly rather than going through a web storefront. Its modular architecture also gives you substantially more control over things like pricing, promotions, fulfillment, payments, and custom business logic. PowerGate Software WPBundle

A typical architecture would look like:

iOS / Android App
   │
   │ HTTPS / API
   ▼
Your API / BFF
   │
   ├── Medusa
   ├── Payment provider
   ├── Search
   ├── CMS
   ├── Notifications
   └── Analytics

That is a very natural architecture if the app is going to become a major product experience rather than simply a mobile version of a website.

🏢 When I'd choose commercetools instead

If you're building for a large organization with:

• multiple countries/currencies
• complex pricing
• B2B accounts
• multiple brands/channels
• sophisticated inventory/fulfillment
• multiple frontends beyond the app
• a dedicated commerce engineering team

I'd strongly consider commercetools.

It's API-first and was designed specifically for headless/composable commerce, making it an excellent foundation for mobile, web, kiosks, marketplaces, etc. Commercetools

The downside is that you're buying into a much more sophisticated architecture—and corresponding cost and engineering overhead.

🧩 When I'd choose Saleor

Saleor is probably my second choice for a technically sophisticated custom app.

It's GraphQL-first and particularly strong if you need multi-channel, multi-warehouse, multi-currency, or B2B functionality. Vendure WPBundle

I'd favor it over Medusa if your team is comfortable with Python/Django and you specifically want a GraphQL-native commerce API.

🛍️ When I'd choose Shopify

Don't discount Shopify.

If the business already uses Shopify, or the priority is getting the app launched quickly while minimizing backend operations, Shopify's Storefront API is an extremely pragmatic choice. You can keep Shopify handling products, orders, payments, customers, etc., while your mobile app is completely custom. Vendure Pharos Production

The tradeoff is that you're accepting Shopify's underlying commerce model. If you eventually need radically custom checkout, pricing, order orchestration, or marketplace logic, an API-first commerce engine such as Medusa or commercetools gives you more freedom.

My decision rule

I'd make the choice roughly like this:

• Startup / new product / TypeScript team → Medusa
• Enterprise / complex global commerce → commercetools
• GraphQL + B2B + multi-channel → Saleor
• Already on Shopify / fastest path to market → Shopify
• Managed SaaS but more headless openness → BigCommerce
• TypeScript + highly customizable backend → Vendure

For a React Native or Flutter app specifically, my personal shortlist would be Medusa vs. Saleor vs. commercetools, with Shopify entering the shortlist if operational simplicity is more important than backend control.

If you tell me (1) B2C vs B2B, (2) approximate SKU count, (3) expected order volume, (4) whether you need subscriptions, and (5) React Native/Flutter/native, I can narrow this to the best 1–2 choices and lay out the recommended mobile architecture.

It's GraphQL-first and particularly strong if you need multi-channel, multi-warehouse, multi-currency, or B2B functionality. Vendure WPBundle

I'd favor it over Medusa if your team is comfortable with Python/Django and you specifically want a GraphQL-native commerce API.

🛍️ When I'd choose Shopify

Don't discount Shopify.

If the business already uses Shopify, or the priority is getting the app launched quickly while minimizing backend operations, Shopify's Storefront API is an extremely pragmatic choice. You can keep Shopify handling products, orders, payments, customers, etc., while your mobile app is completely custom.

The tradeoff is that you're accepting Shopify's underlying commerce model. If you eventually need radically custom checkout, pricing, order orchestration, or marketplace logic, an API-first commerce engine such as Medusa or commercetools gives you more freedom.

My decision rule

I'd make the choice roughly like this:

For a CMS-first commerce architecture (where editors own the product storytelling/page experience and commerce APIs provide catalog, pricing, cart, checkout), I’d usually avoid letting the commerce platform “own” the product page layout. Instead:

Headless CMS = page composition + merchandising story
Commerce API = product truth + transactions

The best platform depends on your scale and how much control you want.

Best fits

1. Shopify + headless CMS — best default for most brands

Good choice if you want:

• Fast implementation
• Strong merchant tooling
• Reliable checkout, payments, inventory
• A CMS layer for richer product pages

Typical stack:

• CMS: Sanity, Contentful, or Storyblok
• Commerce: Shopify Storefront API
• Frontend: Next.js

Shopify supports custom storefronts where the frontend is separated from Shopify’s commerce backend and consumes commerce data through APIs. Shopify Shopify

Choose this if: you’re DTC, mid-market, or want the best balance of flexibility and operational simplicity.

2. BigCommerce + CMS — best if API-first commerce is a priority

Good choice if:

• You need more open commerce APIs
• You have B2B requirements
• You want multi-storefront capability
• You expect more composable architecture

BigCommerce explicitly supports headless builds using CMS platforms, Next.js, GraphQL storefront APIs, and custom frontends. BigCommerce BigCommerce

Choose this if: commerce complexity matters more than having the largest app ecosystem.

3. commercetools + CMS — best enterprise option

Good choice if:

• Product models are complex
• You have ERP/PIM integrations
• You need multiple channels (web, app, kiosks, marketplaces)
• You have engineering resources

It’s designed for composable commerce and commonly paired with CMS platforms to separate content modeling from commerce capabilities. commercetools Documentation

Choose this if: you are building a long-lived commerce platform, not just a storefront.

4. Medusa + CMS — best for engineering-led teams

Good choice if:

• You want ownership of the stack
• You need custom workflows
• You have developers comfortable maintaining infrastructure

Choose this if: you want maximum control and accept more engineering responsibility.

My recommendation by scenario

Product page architecture I’d use

A CMS-driven product page might own:

• Hero media
• Brand story
• Editorial copy
• Lifestyle content
• Buying guides
• FAQs
• SEO fields
• Related content blocks
• Merchandising rules

Commerce API owns:

• SKU
• Price
• Inventory
• Variants
• Promotions
• Cart
• Checkout
• Customer accounts

A common mistake is putting everything in the CMS, including price and inventory. Keep transactional data in commerce.

For most teams today, I’d start with Next.js + Sanity (or Contentful) + Shopify Storefront API unless you already know you have enterprise-scale commerce requirements. Shopify’s API-first approach is specifically designed to support custom storefronts and integrations with CMS/PIM/ERP systems. Shopify

If you tell me your scale (SKU count, B2C vs B2B, number of markets, and whether editors need drag-and-drop page building), I can narrow this to a specific stack.

For most teams today, I’d start with Next.js + Sanity (or Contentful) + Shopify Storefront API unless you already know you have enterprise-scale commerce requirements. Shopify’s API-first approach is specifically designed to support custom storefronts and integrations with CMS/PIM/ERP systems.

For a team that already prefers serverless frontends + JAMstack, I’d bias toward commerce platforms that are truly API-first, work well with Next.js/Astro/Nuxt-style frontends, and don’t require you to run a traditional ecommerce application server. JAMstack/headless commerce works by separating the storefront from the commerce backend, with APIs connecting the two layers. Shopify

The best fits usually fall into these groups:

My shortlist by team profile

1. “We build mostly Next.js/Astro and want minimal ops”

Pick:

• Shopify headless
• Medusa

This gives you:

• serverless frontend deployment
• CDN-friendly pages
• API-driven product/catalog data
• webhooks for revalidation
• no ecommerce backend in your frontend runtime

A common stack:

Next.js / Astro
        |
        | API calls
        |
Commerce backend
        |
Payments / inventory / fulfillment

2. “Our developers want maximum control”

Look at:

• Medusa
• Saleor
• Vendure

These are better when you expect unusual workflows:

• marketplaces
• custom pricing
• complex product logic
• nonstandard checkout flows

The tradeoff is more engineering ownership. CozyCommerce Your Next Store

3. “We are enterprise-scale”

Look at:

• commercetools
• Commerce Layer

These make sense when you need:

• multiple regions
• multiple storefronts
• ERP/PIM/OMS integrations
• many sales channels

They are powerful but usually require a stronger platform engineering team. Vendure

Don’t forget the CMS layer

A JAMstack commerce build often separates:

• Commerce engine: products, cart, checkout, orders
• Headless CMS: landing pages, editorial content, merchandising

Popular pairings:

• Shopify + Sanity
• Medusa + Sanity
• Saleor + Contentful
• Commerce Layer + Contentful

AlphansoLabs |For most teams already committed to serverless frontends, my practical ranking would be:

1. Shopify headless — fastest path to a production-grade store
2. Medusa — best developer experience if you want ownership
3. Saleor — best GraphQL-native option
4. commercetools — best when enterprise complexity justifies it

The deciding question is usually: do you want commerce to be a managed business capability, or do you want it to become part of your product engineering platform?

If your team prefers serverless frontends + JAMstack, I’d prioritize commerce platforms that are strongly API-first, work well with static/SSR/edge frameworks, and keep the operational backend managed.

My shortlist

1. Shopify — best default choice

Shopify is probably the safest choice if you want your frontend to live independently on something like Vercel, Netlify, Cloudflare, or another serverless/edge platform.

Its Storefront API is GraphQL-based and explicitly designed for custom storefronts, while Shopify handles products, inventory, carts, checkout, orders, etc. Shopify also says you can bring essentially any frontend framework and hosting stack. Shopify Shopify

It works particularly well with Next.js, Astro, Gatsby, and Hydrogen. Shopify's Hydrogen/Oxygen stack is also an option if you want a more integrated React + edge deployment approach. Shopify

shopify.dev

2. Saleor — best if "API-first" is the architectural priority

Saleor is arguably an even cleaner architectural match. It's GraphQL-only, API-only, headless, and technology-agnostic, with the frontend and backend completely separated. It supports webhooks and API extensions rather than requiring traditional commerce plugins. Saleor Commerce GitHub

That's attractive if your team thinks of the commerce engine as just another backend service in a composable JAMstack architecture.

The tradeoff is that Shopify generally gives you a more mature turnkey commerce ecosystem and less infrastructure/commerce engineering to own.

saleor.io

3. commercetools — best for enterprise composable commerce

commercetools is a strong choice when you're building a large composable architecture rather than simply replacing a traditional storefront. Its APIs expose commerce capabilities independently, making it well suited to multiple frontend channels and independently evolving services. Commercetools

The downside is complexity: I'd choose it when you actually need that enterprise-level composability rather than because "headless" sounds attractive.

commercetools.com

4. BigCommerce — pragmatic SaaS alternative

BigCommerce also supports custom headless storefronts through APIs and SDKs, with official documentation specifically covering headless architectures and custom storefronts. BigCommerce

It's worth evaluating alongside Shopify if you want SaaS commerce but don't want to automatically default to Shopify.

docs.bigcommerce.com

What I'd pick

For a team saying "we want JAMstack/serverless first", my ranking would be:

1. Shopify — best balance of developer freedom, managed commerce, ecosystem, and speed to market.
2. Saleor — best architectural purity and flexibility if your developers are comfortable owning more of the solution.
3. commercetools — best for complex enterprise composable commerce.
4. BigCommerce — good SaaS/headless alternative.

A typical architecture I'd recommend is:

Astro/Next.js → serverless/edge hosting → commerce API → Shopify/Saleor
with a separate headless CMS → content, and optionally separate search/PIM/ERP services.

The important distinction is that JAMstack doesn't mean the entire shopping experience has to be static. Product/category pages can be statically generated or cached at the edge, while cart, customer, inventory-sensitive pricing, and checkout remain dynamic API interactions. Shopify's Storefront API is explicitly designed around this separation. Shopify help.shopify.com

If you tell me B2C vs B2B, approximate SKU count, expected traffic, and whether you're using Next.js/Astro/Gatsby, I can narrow this to a clear winner and give you a reference architecture.

shopify.dev

2. Saleor — best if "API-first" is the architectural priority

Saleor is arguably an even cleaner architectural match. It's GraphQL-only, API-only, headless, and technology-agnostic, with the frontend and backend completely separated. It supports webhooks and API extensions rather than requiring traditional commerce plugins. Saleor Commerce GitHub

That's attractive if your team thinks of the commerce engine as just another backend service in a composable JAMstack architecture.

The tradeoff is that Shopify generally gives you a more mature turnkey commerce ecosystem and less infrastructure/commerce engineering to own.

saleor.io

3. commercetools — best for enterprise composable commerce

commercetools is a strong choice when you're building a large composable architecture rather than simply replacing a traditional storefront. Its APIs expose commerce capabilities independently, making it well suited to multiple frontend channels and independently evolving services. Commercetools

The downside is complexity: I'd choose it when you actually need that enterprise-level composability rather than because "headless" sounds attractive.

commercetools.com

4. BigCommerce — pragmatic SaaS alternative

BigCommerce also supports custom headless storefronts through APIs and SDKs, with official documentation specifically covering headless architectures and custom storefronts. docs.bigcommerce.com

It's worth evaluating alongside Shopify if you want SaaS commerce but don't want to automatically default to Shopify.

If your priority is developer experience + SDK quality + modern frontend frameworks, my pick in 2026 is Shopify’s headless stack, with Medusa as the best choice if you want maximum backend control.

The interesting part is that Shopify has changed the equation recently: its new Hydrogen developer preview is moving from an opinionated React framework toward a framework-agnostic commerce SDK/toolkit. It supports Next.js, SvelteKit, Nuxt, SolidStart, React Router, and other JavaScript frameworks/runtimes. Hydrogen Shopify

My ranking for frontend developers

🥇 Shopify Hydrogen — best overall

If I were starting a new project where frontend developer productivity was the primary criterion, I'd choose Shopify.

The new Hydrogen toolkit provides a typed Storefront API client, cart/product/collection primitives, Shop Pay integration, analytics, server-driven cart handling, and framework bindings. Crucially, Shopify now explicitly supports using it with Next.js, SvelteKit, Nuxt, SolidStart, and React Router, rather than forcing you into one frontend framework. Shopify

That's a significant advantage over traditional "headless" platforms where you're essentially given an API and expected to build the commerce plumbing yourself.

You can also use Shopify's Storefront API without Hydrogen if you want a completely custom architecture. Shopify

Best for: Next.js/React teams, DTC brands, teams wanting managed infrastructure, fast implementation.

Big caveat: You're still building on Shopify's commerce model. If your business logic fundamentally doesn't fit Shopify, the excellent frontend tooling won't solve that.

🥈 Medusa — best for developers who want ownership

Medusa is probably my favorite alternative for a team that says:

"We want commerce infrastructure, not a SaaS platform telling us how commerce works."

It's TypeScript/Node-based, modular, open source, and designed to let you customize the backend extensively. That makes it particularly attractive if your frontend is Next.js and you want your commerce code to live in the same general JavaScript/TypeScript ecosystem. Ribbsaeter Systems ZORC

The tradeoff is that you own more of the system—deployment, infrastructure, upgrades, and operational concerns.

Best for: Next.js + TypeScript teams, custom checkout/business logic, marketplaces, unusual commerce models.

🥉 Saleor — best API architecture

Saleor is extremely compelling if your frontend team loves GraphQL.

Its API is GraphQL-first, and its documentation has strong API references, tutorials, extensions, dashboard apps, and recipes for multi-region commerce, marketplaces, custom shipping, etc. Saleor Documentation

The main downside compared with Medusa is the backend ecosystem: Saleor is Python/Django, so a TypeScript-heavy frontend organization has to cross that boundary. Hunchbite

Best for: GraphQL-heavy teams, international/multi-channel commerce, sophisticated catalog models.

Enterprise: commercetools

commercetools is the one I'd put ahead of the others for a large enterprise composable architecture.

Its SDK/API ecosystem is mature, and its frontend tooling includes an SDK designed for SSR/Next.js applications. commercetools Documentation

But it's a different proposition from Medusa or Shopify. You're buying into a much more elaborate composable-commerce architecture, which makes sense when you have the organizational complexity to justify it—not necessarily for a startup or small frontend team.

So, what would I choose?

For a modern Next.js/React storefront:

1. Shopify Hydrogen — best developer experience and lowest plumbing burden.
2. Medusa — best if backend ownership/customization matters.
3. Saleor — best if GraphQL is central to your architecture.
4. commercetools — best for large enterprise composable commerce.
5. Vendure — worth serious consideration if you want a TypeScript/NestJS-centric stack.

The particularly interesting choice right now is Shopify. Its 2026 Hydrogen developer preview essentially acknowledges that modern frontend teams don't necessarily want an ecommerce-specific framework: Shopify is turning Hydrogen into commerce primitives + SDK + tooling that can sit inside the framework you already use. Hydrogen Shopify

So if your stack is Next.js + TypeScript + Tailwind + Vercel, I'd lean Shopify Hydrogen/Storefront API unless you have a strong reason to own the commerce backend. If you're building something where the commerce model itself is highly customized, I'd choose Medusa instead.

If I were starting a new project where frontend developer productivity was the primary criterion, I'd choose Shopify.

The new Hydrogen toolkit provides a typed Storefront API client, cart/product/collection primitives, Shop Pay integration, analytics, server-driven cart handling, and framework bindings. Crucially, Shopify now explicitly supports using it with Next.js, SvelteKit, Nuxt, SolidStart, and React Router, rather than forcing you into one frontend framework. Shopify

That's a significant advantage over traditional "headless" platforms where you're essentially given an API and expected to build the commerce plumbing yourself.

You can also use Shopify's Storefront API without Hydrogen if you want a completely custom architecture. Shopify

Best for: Next.js/React teams, DTC brands, teams wanting managed infrastructure, fast implementation.

Big caveat: You're still building on Shopify's commerce model. If your business logic fundamentally doesn't fit Shopify, the excellent frontend tooling won't solve that.

🥈 Medusa — best for developers who want ownership

Medusa is probably my favorite alternative for a team that says:

"We want commerce infrastructure, not a SaaS platform telling us how commerce works."

It's TypeScript/Node-based, modular, open source, and designed to let you customize the backend extensively. That makes it particularly attractive if your frontend is Next.js and you want your commerce code to live in the same general JavaScript/TypeScript ecosystem. Ribbsaeter Systems ZORC

The tradeoff is that you own more of the system—deployment, infrastructure, upgrades, and operational concerns.

Best for: Next.js + TypeScript teams, custom checkout/business logic, marketplaces, unusual commerce models.

🥉 Saleor — best API architecture

Saleor is extremely compelling if your frontend team loves GraphQL.

Its API is GraphQL-first, and its documentation has strong API references, tutorials, extensions, dashboard apps, and recipes for multi-region commerce, marketplaces, custom shipping, etc. Saleor Documentation

The main downside compared with Medusa is the backend ecosystem: Saleor is Python/Django, so a TypeScript-heavy frontend organization has to cross that boundary. Hunchbite

Best for: GraphQL-heavy teams, international/multi-channel commerce, sophisticated catalog models.

Enterprise: commercetools

commercetools is the one I'd put ahead of the others for a large enterprise composable architecture.

Its SDK/API ecosystem is mature, and its frontend tooling includes an SDK designed for SSR/Next.js applications. docs.commercetools.com

But it's a different proposition from Medusa or Shopify. You're buying into a much more elaborate composable-commerce architecture, which makes sense when you have the organizational complexity to justify it—not necessarily for a startup or small frontend team.

So, what would I choose?

For a modern Next.js/React storefront:

For a B2B wholesaler with complex customer-specific pricing + a headless/API-first storefront, I’d shortlist Adobe Commerce and commercetools first.

My recommendation: Adobe Commerce B2B

For your specific requirements, Adobe Commerce B2B is probably the safest choice if your pricing model is genuinely complicated.

It has native company accounts, shared catalogs, customer-specific pricing, tier pricing, negotiated quotes, purchase orders/approval rules, requisition lists, quick order, and payment-on-account/credit. developer.adobe.com

The shared-catalog model is particularly relevant for wholesale: you can create custom catalogs assigned to companies and give each company its own product assortment and prices. Custom prices can be fixed amounts, percentages, and quantity-based tiers. experienceleague.adobe.com

It also exposes B2B functionality through REST APIs, including shared-catalog management, making it viable for a headless storefront. developer.adobe.com

Choose Adobe if: your business has lots of customer-specific rules, ERP integration, negotiated pricing, complex catalogs, multiple buyer roles, or workflows that will require customization.

When I'd choose commercetools instead

If headless/API-first architecture is the #1 requirement, I'd seriously consider commercetools.

Its pricing model can scope prices by customer group, channel, country, and currency, and its current B2B offering includes APIs for business-unit hierarchies, granular buyer permissions, approvals, and quote management. docs.commercetools.com

The tradeoff is that you're buying a composable commerce platform rather than an all-in-one B2B application. You'll generally need a stronger engineering team and more surrounding services.

The decision I'd make

Adobe Commerce B2B → best if you want deep B2B functionality out of the box and are willing to customize it.

commercetools → best if you want maximum architectural flexibility and API-first/headless commerce, and you have the engineering capability to assemble the platform.

BigCommerce B2B → worth evaluating if you want something simpler/faster to deploy without going all the way into enterprise composable architecture.

If you tell me roughly how you calculate customer pricing (e.g. customer × SKU × quantity × contract × region) and what ERP you're integrating with, I can narrow this down to the best 2–3 platforms and compare their APIs, pricing engines, quote workflows, and implementation complexity.

For a subscription box business, I’d focus less on “does it have a subscription API?” and more on how much subscription logic you want the platform to own. Subscription boxes often need things like:

• recurring billing
• skip/pause/swap boxes
• build-a-box flows
• prepaid plans (3/6/12 months)
• customer portal
• inventory allocation before renewal
• upcoming box previews
• add-ons and upsells
• failed payment recovery
• fulfillment scheduling

My shortlist:

My recommendation by business stage

If you have <10k subscribers

I’d usually choose:

Shopify + a subscription engine
You get:

• proven checkout
• payments
• tax/shipping ecosystem
• less engineering

Use your own headless frontend if you need it, but don’t rebuild subscription billing unless your model is unusual.

If subscriptions are your core product

Example: every customer has a highly personalized box, swaps items monthly, has credits, tiers, loyalty, etc.

I’d lean toward:

Medusa + Stripe Billing (or another billing provider)

Why:

• you control the subscription data model
• you can expose your own API
• you can build custom workflows around boxes, inventory, and fulfillment

Medusa specifically documents building subscription purchases with custom workflows, API routes, and renewal handling rather than forcing a fixed subscription model. Medusa Docs Medusa Docs

If you’re doing $5M+ GMV or have a large engineering team

Consider:

commercetools

It is very flexible, but you’ll be assembling more pieces yourself. It’s powerful when you have the team to own the architecture. commercetools Documentation

Architecture I’d pick for a serious subscription box company

A common strong setup:

• Frontend: Next.js
• Commerce: Medusa or Shopify headless
• Billing: Stripe Billing
• CMS: Sanity / Contentful
• Search: Algolia / Elastic
• Customer data: Segment + your CRM
• Fulfillment: custom service or 3PL integration

The key question

Which category are you in?

1. Monthly curated box (same concept every month, maybe swaps)
2. Build-your-own box (customers choose items)
3. Personalized subscription (quiz/profile drives contents)
4. Membership + recurring perks
5. Wholesale/B2B subscription boxes

The answer changes the best platform quite a bit.

Consider:

commercetools

If international commerce is the primary requirement, I’d shortlist commercetools and Saleor, with the choice depending on how much enterprise complexity you need.

My ranking

🥇 Most robust: commercetools

If by "robust" you mean many countries, currencies, languages, price books, tax rules, regional catalogs, localized payment methods, multiple storefronts, and complex business rules, I'd pick commercetools.

Its project configuration explicitly models countries, currencies, and languages, while its frontend architecture supports multi-language and multi-region deployments. docs.commercetools.com

The big advantage is that internationalization isn't just a storefront concern. You can model regional commerce rules throughout the commerce layer. That's particularly valuable when you eventually have things like:

• USD / EUR / GBP / JPY / CAD pricing
• country-specific price lists
• different catalogs by market
• regional tax/VAT behavior
• different payment providers
• localized product data
• multiple brands/storefronts
• B2B + B2C
• country-specific fulfillment

Downside: it's considerably more enterprise-oriented and architecturally involved. You're buying a powerful commerce infrastructure rather than a particularly opinionated ecommerce application.

🥈 Best modern alternative: Saleor

I'd take a very serious look at Saleor if you're building a new system today.

Saleor's channel model maps particularly nicely to international commerce: channels can represent markets with their own currency, pricing, stock, payment methods and shipping configuration. Its documentation also has explicit multi-region functionality. saleor.io

The current Saleor storefront architecture supports URLs such as:

/en/us/... → English + US/USD
/en/uk/... → English + UK/GBP
/pl/pl/... → Polish + Poland/PLN

including translated product slugs and locale-aware SEO/hreflang handling. github.com

That's unusually good for an international headless build because market and language are separate concepts. You can have English-US, English-UK, French-CA, etc., without turning your architecture into a mess.

Saleor also supports currency-specific channels, regional taxes, shipping zones, payment integrations, and dynamic tax/shipping logic. saleor.io

When I'd choose each

Choose commercetools if:

• you're a large enterprise
• 10+ markets are likely
• complex pricing/catalog rules are expected
• B2B is important
• you need sophisticated integrations with ERP/PIM/OMS
• you have a strong commerce engineering team
• this platform needs to last 7–10+ years

Choose Saleor if:

• you're building a modern headless stack from scratch
• GraphQL is attractive
• international DTC is the core use case
• you want excellent market/channel modeling without quite as much enterprise machinery
• you want more control over the application architecture
• you're using Next.js/React

Choose Shopify/Hydrogen if:

• minimizing operational burden matters more than maximum architectural control
• you want the fastest route to production
• Shopify's international capabilities already cover most of your business requirements.

My recommendation

For a new international brand, I'd probably choose:

Saleor → unless you have very complex enterprise requirements → commercetools.

For example, if you're selling in US + Canada + UK + EU + Australia + Japan, with localized languages/currencies, regional pricing, payment methods, taxes and inventory, Saleor is an extremely compelling fit. Its current architecture was explicitly designed around channels, regions and localization. saleor.io

If you're talking about something more like Nike/Adidas/L'Oréal-scale commerce, where the commerce engine needs to become a central piece of a huge enterprise ecosystem, I'd lean commercetools.

If you tell me your approximate number of countries, languages, currencies, SKU count, B2B vs B2C, and whether you need regional pricing/catalogs, I can give you a much more definitive Saleor vs commercetools vs Shopify Hydrogen recommendation.

Yes. If your goal is one commerce backend powering both web and in-store screens through the same APIs, I’d shortlist these:

My pick: commercetools

For the architecture you're describing, commercetools is probably the strongest fit.

The important distinction is that you don't want:

Web storefront → commerce API
In-store screen → separate POS API
→ synchronize them afterward

You want:

Web UI ─┐
In-store UI ─┼→ shared commerce APIs → catalog / pricing / inventory / customer / cart / order
Mobile UI ─┘

commercetools' model is particularly well suited to that because Stores can represent physical retail locations or regions, while distribution/supply channels let you control assortment, prices and inventory. commercetools Documentation commercetools Documentation

For example, an in-store screen could use the same underlying product/catalog APIs as your website, but be scoped to:

Store = Boston Flagship
Inventory = Boston
Price = Retail
Assortment = Flagship assortment

while the web experience could use:

Store = Online US
Inventory = E-commerce warehouses
Price = Online

That gives you one commerce model with channel-specific context, rather than maintaining separate commerce implementations.

BigCommerce is the better alternative if you prioritize faster implementation and a more conventional SaaS commerce platform. Its headless APIs explicitly support storefronts such as websites, native apps and kiosks, and its channel model is quite mature. BigCommerce BigCommerce

If you tell me whether the in-store screens are POS checkout terminals, associate tablets, customer-facing kiosks, or digital signage, I can narrow this to the best 2–3 architectures and show what the API layer would look like.