Answers that name a competitor

For a small clothing brand where you want headless flexibility without creating a lot of infrastructure to maintain, I’d lean toward Shopify as the commerce backend, with a custom frontend.

How I’d compare the main options

Why Shopify: its Storefront API is specifically designed for headless storefronts, and you can use essentially whatever frontend stack you want—Next.js, Hydrogen, Vue, etc. Shopify continues to handle the underlying commerce infrastructure, while you control the customer-facing experience. Shopify Shopify

That means you could have something like:

Next.js storefront → Shopify Storefront API → Shopify commerce backend

while Shopify handles products, inventory, carts, orders, customers, checkout infrastructure, etc. Shopify says the Storefront API is designed to operate at large scale, and buyer traffic isn't subject to a fixed requests-per-minute limit. Shopify Shopify

shopify.dev

When I'd choose Medusa instead

Medusa Cloud becomes more compelling if "flexibility" means I want to change the underlying commerce behavior, not merely build a custom frontend. It's open-source and gives you substantially more control over the commerce engine, while its Cloud offering handles deployment, environments and infrastructure management. Medusa Docs

docs.medusajs.com

Saleor is another strong API-first option, particularly if your team is comfortable with GraphQL/Python and expects unusual commerce requirements. Its architecture is explicitly designed around headless APIs and extensions. Saleor Documentation Saleor Commerce

My practical recommendation

For a small clothing brand today, I'd start with:

Shopify backend + Next.js/Hydrogen frontend.

You get the freedom to make the storefront completely custom without taking on the operational responsibility of running your own commerce backend. Shopify also supports bringing your own stack rather than forcing you into Hydrogen. Shopify Shopify

I'd only move to Medusa/Saleor if you already know you'll need things like highly customized checkout/business rules, unusual product/order models, marketplace functionality, or much deeper ownership of the backend.

If you tell me your approximate monthly orders, whether you need subscriptions/wholesale, and what frontend you plan to use (Next.js, Shopify Hydrogen, etc.), I can narrow this down to an architecture and estimated monthly stack cost.

For a small clothing brand, I’d optimize for the combination of:

1. Low operational burden (you don’t want to babysit servers)
2. Room to customize (branding, drops, bundles, loyalty, subscriptions, experiments)
3. A path to scale without rebuilding everything

The best fit is usually one of these:

powergatesoftware.comribbsaetersystems.com

My recommendation: start with Shopify headless

For a small clothing brand, I’d generally choose Shopify as the commerce backend and build a custom frontend only if you actually need it.

A practical stack:

• Frontend: Next.js / React
• Commerce backend: Shopify Storefront API
• CMS: Sanity or Contentful for editorial content
• Search: Algolia if your catalog grows
• Payments/inventory/orders: Shopify handles these

Why:

• You avoid maintaining databases, checkout logic, tax rules, fraud tooling, and inventory systems.
• Your team can spend time on collections, campaigns, photography, and customer experience.
• You can still have a completely custom storefront.

Shopify’s headless approach is commonly used by brands that want custom experiences while keeping a managed commerce backend. powergatesoftware.comribbsaetersystems.com

When I would pick Medusa instead

Pick Medusa if you expect unusual requirements like:

• Custom product configurators
• Unique fulfillment workflows
• Marketplace-style features
• Very custom pricing rules
• You want ownership of the entire commerce codebase

The tradeoff is that you become responsible for more infrastructure and engineering. hunchbite.com

What I would avoid initially

I would probably not start with a fully self-hosted headless backend unless you already have engineering capacity. A clothing brand’s bottleneck is usually not commerce infrastructure—it’s product, content, acquisition, and retention.

A sensible growth path:

Stage 1 (launch → ~$1M revenue):

• Shopify backend
• Custom Next.js frontend only if needed

Stage 2 (complex operations):

• Add dedicated CMS/search/personalization services

Stage 3 (unique commerce model):

• Consider Medusa, Saleor, or a custom commerce layer

If you tell me your current setup (Shopify/WooCommerce/custom), monthly order volume, number of SKUs, and whether you have a developer, I can narrow this to a specific architecture.

For a mid-size retailer on a tight timeline, I’d shortlist:

• Shopify + Hydrogen — likely the fastest path if you’re already on Shopify. Hydrogen provides a purpose-built headless stack, commerce components, Storefront API integration, and straightforward deployment via Oxygen. Shopify Shopify
• BigCommerce + Catalyst — strong alternative if you want a Next.js/React headless storefront with more backend flexibility. Catalyst includes production-ready commerce functionality rather than making you build everything yourself. BigCommerce BigCommerce
• commercetools — better suited when you need highly composable, complex commerce architecture, but generally entails more implementation effort. Naturaily

For speed, I’d start with Shopify Hydrogen unless you have a specific reason not to use Shopify. Shopify's current migration tooling also supports shared carts between traditional and Hydrogen storefronts, which can reduce migration risk. Shopify

If you tell me your current platform, frontend stack, integrations (ERP/PIM/CMS), and target launch window, I can narrow this to a concrete implementation choice.

For a mid-size retailer on a tight implementation timeline, I’d narrow it to Shopify Hydrogen and BigCommerce Catalyst, with commercetools mainly if you already have a strong engineering/composable-commerce team.

My practical shortlist

1. Shopify + Hydrogen — I'd investigate this first if you're willing to use Shopify as the commerce backend. Hydrogen is Shopify's purpose-built headless stack, with prebuilt commerce components, Storefront/Customer APIs, CLI tooling, and deployment through Oxygen. Shopify specifically describes Hydrogen/Oxygen as its recommended headless stack. Shopify Shopify

The big advantage on a deadline is that you're not building fundamental commerce plumbing yourself: Hydrogen already provides things such as cart functionality, while checkout remains Shopify-hosted. Shopify Shopify

2. BigCommerce + Catalyst — particularly attractive if you want Next.js/React and a more API-oriented backend. Catalyst is BigCommerce's maintained headless storefront framework and comes with a functional B2C storefront, product/search/cart capabilities, and a hosted checkout flow. BigCommerce BigCommerce

BigCommerce also has a One-Click Catalyst setup that can create a storefront and preview environment, which is useful when time-to-first-working-site matters. BigCommerce

3. commercetools — powerful, but I'd be cautious about choosing it because you're under time pressure. Its modular/API-first approach gives you substantially more architectural freedom, but that flexibility generally means more decisions and integration work. commercetools positions itself as a composable platform built around independently scalable commerce capabilities. commercetools commercetools

The deciding question

If you tell me (1) what you're migrating from, (2) approximate annual online revenue/order volume, (3) whether you're already on Shopify/BigCommerce/etc., and (4) your frontend stack/team size, I can give you a much more concrete 30/60/90-day implementation comparison, including where each option tends to create migration bottlenecks.

For a solo developer building a headless storefront for digital downloads, I’d usually narrow it to:

1. Lemon Squeezy — simplest “developer-first” option
2. Stripe — best API, but more work
3. Gumroad — simplest selling flow, weaker headless experience
4. Paddle — good if you need merchant-of-record SaaS billing

My pick for a solo dev: Lemon Squeezy. Lemon Squeezy Docs Lemon Squeezy Docs

Why Lemon Squeezy fits a headless digital-download storefront

You can keep your own frontend (Next.js, Astro, Remix, etc.) and let Lemon Squeezy handle the hard commerce pieces:

• Product catalog
• Checkout
• Payment processing
• Digital file delivery
• Taxes/VAT handling
• Customer/order records
• Webhooks for fulfillment flows

Its API is relatively small: create products in the dashboard, generate checkout links, listen for purchase events, then unlock downloads in your app. The API uses standard HTTP requests and webhooks, though it follows JSON:API conventions, which adds a little verbosity. Lemon Squeezy Docs Lemon Squeezy Docs

A typical architecture:

Your storefront
      |
      |  "Buy" button
      ↓
Lemon Squeezy checkout
      |
      | webhook: order_created
      ↓
Your backend
      |
      ↓
Grant download access

When I would choose something else

My rough decision guide

• Selling PDFs, templates, assets, ebooks, courses: Lemon Squeezy or Gumroad
• Selling a developer tool, plugin, app license, or SaaS add-on: Lemon Squeezy
• Building a serious commerce platform: Stripe
• Want the fastest MVP with your own frontend: Lemon Squeezy

For a solo developer, I’d avoid building a full cart/order system unless commerce itself is your product. A lightweight stack like:

• Next.js frontend
• Lemon Squeezy checkout
• Your database for users + entitlements
• Webhooks for fulfillment

is usually the lowest-maintenance path. Lemon Squeezy Docs Lemon Squeezy Docs

If you tell me your stack (Next.js? Laravel? Rails? Svelte?) and whether you need one-time downloads vs subscriptions/licenses, the recommendation may change.

For a solo developer building a headless storefront for digital downloads, I’d look first at Lemon Squeezy if your priority is minimum integration complexity. Its model maps neatly to a custom frontend: create products/variants, generate a checkout URL or checkout via API, then use webhooks to provision the download/access after purchase. Lemon Squeezy Docs Lemon Squeezy Docs Lemon Squeezy Docs

How I’d compare the main options

Why Lemon Squeezy is particularly attractive: its docs explicitly support hosted or overlay checkout, while also letting you create fully customized checkout experiences through the API. Lemon Squeezy Docs You can attach your own user/order identifier as custom checkout data and receive it back in webhooks, which is convenient for connecting purchases to users in your own database. Lemon Squeezy Docs

The webhook side is also fairly clean: events such as order_created and license_key_created arrive as JSON POSTs, with signature validation available. Lemon Squeezy Docs Lemon Squeezy Docs

Paddle is a strong alternative if you expect more sophisticated billing requirements. Its current API revolves around products, prices, transactions and checkout, and its JavaScript checkout can be driven directly from your frontend. Paddle Developer Docs Paddle Developer Docs It also handles payments, tax and compliance as a Merchant of Record. Paddle Developer Docs The tradeoff is that there's somewhat more conceptual machinery than you need for a simple download shop.

My practical recommendation

For a solo developer, I'd structure it roughly:

Your frontend → Lemon Squeezy checkout → webhook → your DB → your download authorization

That keeps payment/tax/order infrastructure out of your codebase while letting you own the actual storefront UX.

If you tell me your stack (e.g. Next.js + Supabase, Astro, Laravel, etc.), I can also compare Lemon Squeezy vs Paddle vs Stripe specifically for that stack, including the approximate amount of code each integration requires.

For an agency that builds custom frontends for clients, I would avoid picking a single platform for every project. Your recommendation should depend on whether the client values speed, flexibility, enterprise scale, or ownership.

A practical shortlist:

Shopify Commercetools## My agency-oriented recommendation

Default recommendation: Shopify headless

For most client projects, I would lead with Shopify + custom frontend (Next.js/React/Hydrogen).

Why:

• Clients get a mature admin, payments, fulfillment, apps, and operational tooling.
• Your agency still owns the UX layer.
• Easier handoff to non-technical client teams.
• Strong Storefront API for custom experiences. Shopify

Architecture:

Next.js storefront
        |
Shopify Storefront API
        |
Shopify Admin / Checkout / Apps

The downside: it is usually multi-store, not a true SaaS multi-tenant architecture. If your agency wants to run "one platform powering hundreds of client storefronts," Shopify becomes awkward.

If you are building a reusable commerce platform: Medusa

If your business model is closer to:

"We build a commerce engine where every client gets their own storefront"

then I would strongly consider Medusa.

You can model:

One Medusa deployment

Tenant A
 ├── Products
 ├── Customers
 ├── Orders
 └── Storefront

Tenant B
 ├── Products
 ├── Customers
 ├── Orders
 └── Storefront

Medusa has store concepts and APIs intended for custom storefronts, and its modular architecture lets teams customize commerce workflows. Its documentation notes that multiple stores can be managed within an instance, though more advanced multi-tenancy patterns require customization. Medusa Docs Medusa Docs

Typical stack:

Next.js
 |
BFF/API Gateway
 |
Medusa
 |
Postgres
 |
CMS (Sanity, Contentful, Payload)

This is attractive if your agency wants to create a productized offering.

Enterprise clients: commercetools

For large organizations with:

• multiple brands
• countries
• currencies
• complex pricing
• B2B workflows
• multiple channels

I would look at commercetools.

It is built around API-first composable commerce, where frontend experiences consume commerce capabilities through APIs rather than being tied to a storefront. Commercetools

The tradeoff is implementation complexity. Your agency needs stronger architecture capability and longer engagements.

A platform stack I would standardize as an agency

I would probably create three tiers:

Tier 1 — Marketing/ecommerce brands

Shopify headless + Next.js + CMS

Use for:

• apparel
• beauty
• food
• consumer brands

Tier 2 — Multi-brand / marketplace-style clients

Medusa + Next.js + CMS

Use for:

• franchises
• vendor platforms
• niche marketplaces
• "we need 50 storefronts" scenarios

Tier 3 — Enterprise

commercetools + custom frontend

Use for:

• global retailers
• B2B commerce
• complex integrations

One architecture decision I would make early: separate tenant/store identity from the frontend. For example:

client1.com
   ↓
tenant_id=client1

client2.com
   ↓
tenant_id=client2

Then your frontend layer stays reusable regardless of the commerce backend.

If your agency is trying to create a repeatable "storefront factory" offering, I would lean Medusa. If you mostly build bespoke experiences for established brands, I would make Shopify headless the default.

For an agency building custom frontends repeatedly across clients, I’d narrow the shortlist to Vendure, Medusa, and commercetools, with the right choice depending on what you mean by “multi-tenant.”

Vendure explicitly documents a multi-tenant architecture where multiple shops can run in one Vendure instance, with a Channel per tenant and tenant-specific permissions/configuration. Vendure Medusa also supports multiple stores within one instance, although its own documentation notes that native multi-tenancy isn't provided and that you build the association/isolation between stores and their resources. Medusa Documentation

What I'd recommend for an agency

1. Vendure — if multi-tenancy is a core requirement

I'd seriously consider making Vendure your agency's default commerce backend if your clients need things like:

• One backend serving multiple stores/brands
• Separate product catalogs, pricing, inventory, etc.
• Custom Next.js/React frontends
• Strong TypeScript integration
• GraphQL APIs
• Custom checkout/business logic
• B2B as well as B2C
• Marketplace-like or multi-brand architectures

Its Channel abstraction maps unusually well to the agency scenario: one commerce deployment → many client/store contexts → independently customized frontends. Vendure itself documents using Channels to create multi-tenant setups. Vendure

Its current storefront stack is also Next.js/React/TypeScript with GraphQL, while allowing you to replace the frontend entirely with your own. Vendure

2. Medusa — if your agency prioritizes flexibility

I'd choose Medusa when your team wants a more modular, developer-oriented commerce engine and is comfortable implementing the tenant abstraction itself.

It's particularly attractive if your standard agency stack is:

Next.js + TypeScript + Postgres + custom integrations

Medusa's architecture gives you considerable freedom to build custom commerce workflows rather than forcing clients into a predefined SaaS model. The important caveat for your use case is that multi-store ≠ fully implemented multi-tenancy: Medusa lets you manage multiple stores, but tenant isolation and the relationships between resources require your architecture. Medusa Documentation

That can actually be an advantage for an agency if you want to create your own reusable tenant layer once and reuse it across projects.

3. commercetools — when the client is enterprise

For a large retailer or enterprise client, I'd move toward commercetools rather than trying to turn an open-source engine into an enterprise commerce platform.

It's API-first/composable and designed for organizations with complex catalogs, markets, channels, integrations and multiple commerce experiences. The tradeoff is that you're buying into a much more enterprise-oriented platform and operating model. Current industry comparisons generally put commercetools alongside the enterprise composable platforms rather than the developer-oriented engines. Vendure

The architecture I'd build for your agency

If you're trying to create a repeatable agency offering, I'd actually standardize the frontend/backend boundary rather than standardizing the entire website:

                    ┌─────────────────────┐
                    │   Agency Frontend   │
                    │ Next.js / React     │
                    └──────────┬──────────┘
                               │
                         Commerce API
                               │
                    ┌──────────▼──────────┐
                    │   Vendure / Medusa  │
                    │                     │
                    │ Tenant A            │
                    │ Tenant B            │
                    │ Tenant C            │
                    │ ...                 │
                    └──────────┬──────────┘
                               │
             ┌─────────────────┼─────────────────┐
             ▼                 ▼                 ▼
          Payments          ERP/CRM            CMS
          Stripe/etc.       Client systems     Content

Then your agency owns a reusable frontend starter:

agency-commerce/
├── storefront/
│   ├── product/
│   ├── collection/
│   ├── cart/
│   ├── checkout/
│   └── account/
├── components/
├── commerce/
│   ├── products.ts
│   ├── cart.ts
│   ├── checkout.ts
│   └── customer.ts
├── tenant/
│   ├── configuration.ts
│   ├── branding.ts
│   └── routing.ts
└── cms/

Each client then gets its own:

tenant
├── domain
├── branding
├── catalog
├── pricing
├── payment configuration
├── CMS content
└── frontend configuration

That gives you the agency equivalent of a commerce operating system: your clients get genuinely custom frontends, while your team doesn't reinvent product/catalog/cart/checkout infrastructure for every engagement.

My practical shortlist

If I were evaluating this for an agency today, I'd do a technical spike with:

Vendure vs. Medusa

and only bring in commercetools when the client requirements justify an enterprise SaaS platform.

The key question I'd test isn't “which has the most features?” It's “can we provision a new tenant/store, isolate its data, connect a custom Next.js frontend, and deploy it repeatedly without bespoke engineering?”

If multi-tenant SaaS commerce is actually the product you're building for your clients—not merely multiple storefronts for one merchant—I'd lean toward Vendure as the starting point, because its Channel model maps directly onto that architecture. Vendure

For a startup with limited funding, I’d focus on total cost of ownership rather than raw feature count. Based on current 2026 pricing and capabilities, Medusa is a particularly cost-efficient option if you have some engineering capability. Medusa Docs Medusa

Why I'd look at Medusa first

medusajs.com is open source and can be self-hosted, so the software itself doesn't require a large platform subscription. Its managed Cloud currently starts at $29/month, with Launch at $99/month and Scale at $299/month, and Medusa states that its Cloud plans have 0% GMV platform fees. Medusa Docs Medusa

That gives you a useful progression:

• Very early MVP: self-host Medusa → minimize software costs.
• Launching: Medusa Cloud Develop → $29/month starting point.
• Growing traffic: Launch → $99/month, adding things such as autoscaling, backups, custom domains and Redis-backed KV.
• More complex operation: Scale → $299/month, adding background workers and additional infrastructure. Medusa Docs

The main tradeoff is engineering effort. Headless commerce isn't inherently cheap just because the commerce engine is open source—you still need developers to build the storefront, integrations, deployment, monitoring, etc.

When I'd choose something else

Shopify + Hydrogen makes sense if your startup has limited engineering resources, rather than merely limited cash. You're paying more for a managed commerce backend, but you get Shopify's established commerce infrastructure and ecosystem. Current comparisons describe Hydrogen as the lower-operational-burden route, while Medusa gives you substantially more ownership and customization. Ribbsaeter Systems Ask An Tech

Saleor is worth considering if you specifically need its GraphQL-first architecture, sophisticated multi-channel/international capabilities, or have a Python team. Its managed offering is much more expensive than Medusa's at the current published pricing, so it is harder to justify for a cash-constrained startup unless you need those capabilities. Saleor Eryx Innovations Lab

My practical decision rule

• You have 1–3 capable developers: Medusa
• You have little/no engineering capacity: Shopify + Hydrogen
• You need complex B2B/multi-market capabilities from the outset: investigate Saleor
• You're already operating at enterprise scale: look at commercetools/other enterprise composable platforms

So, for the specific constraint "startup + limited funding + wants headless", I'd put Medusa at the top of the shortlist, provided you have enough engineering capability to own a headless stack. ShipGarden Medusa Docs

If you tell me your monthly budget, expected orders/month, tech stack (Next.js/React/etc.), and whether you need B2B, I can narrow this down to a concrete architecture and estimated monthly cost.

For a startup with limited funding, I’d focus on total cost of ownership rather than the biggest feature list. Based on current 2026 pricing and capabilities, Medusa is a particularly strong fit if you have some engineering capability.

Why I'd look at Medusa first

Medusa currently offers managed Cloud starting at $29/month, with no GMV/platform fee, unlimited products, orders, sales channels, regions and currencies. Its $99/month Launch tier adds things such as autoscaling, custom storefront domains, backups and webhooks. Medusa Medusa Documentation

That makes it attractive when you're trying to keep recurring costs predictable while retaining a genuinely headless architecture. It's also open-source, so you retain ownership of the application code rather than being locked into a proprietary commerce backend. Ribbsaeter Systems ShipGarden

The tradeoff is that you need developers. You'll still be responsible for building/customizing parts of the storefront and commerce experience, and the deeper you customize Medusa, the more engineering becomes part of your TCO.

When Shopify makes more sense

Shopify with Hydrogen is worth considering if your startup has very little engineering capacity. You get Shopify's mature commerce infrastructure and ecosystem while using a custom headless storefront. The tradeoff is paying for Shopify's SaaS infrastructure and accepting more platform constraints. Current industry comparisons generally characterize Hydrogen as the lower-operational-burden option versus open-source engines such as Medusa. Ribbsaeter Systems Techpuvi Innovations

In other words:

• Small engineering team + very limited budget: Medusa
• Tiny/nontechnical team + need to launch quickly: Shopify + Hydrogen
• Python/GraphQL team + sophisticated B2B/multichannel requirements: Saleor
• Enterprise-scale requirements: commercetools or similar platforms

One important caveat: Saleor's open-source core is free, but managed Saleor Cloud is aimed at considerably larger budgets—its currently published Cloud pricing starts around $1,599/month for Select, while the Volume tier is $3,999/month. Saleor Commerce Softwr

My practical startup architecture: Medusa + Next.js + a managed PostgreSQL database + Stripe. That gives you a relatively inexpensive starting point without painting yourself into a corner if the business grows.

If you tell me your monthly budget, expected monthly orders, team size/technical stack, and B2C vs. B2B, I can narrow this down to the most economical architecture and estimate your first-year TCO.

When Shopify makes more sense

For an enterprise catalog with thousands of SKUs, the key differentiators are usually not the SKU count itself, but whether the platform can handle:

• complex product types (configurable products, bundles, variants, kits, BOMs)
• multiple catalogs and assortments by customer/region/channel
• rich attributes and inheritance
• customer-specific pricing and entitlements
• ERP/PIM integration
• fast product queries through APIs
• governance for merchandisers without constant developer work

A shortlist I’d typically evaluate:

My practical split

Choose commercetools if:

• your engineering team wants maximum flexibility
• you are building a custom commerce stack
• your product model is highly variable across channels
• you expect many integrations and custom workflows

Its strength is that nearly everything is modeled as API-accessible commerce resources, but it typically requires stronger engineering ownership. commercetools

Choose Elastic Path if:

• you sell through distributors, dealers, or B2B accounts
• you need complex catalogs plus pricing rules
• business teams need more commerce functionality without building everything themselves

Elastic Path positions itself around complex B2B/B2B2C use cases and composable commerce. Elastic Path

Choose SAP Commerce Cloud if:

• SAP S/4HANA or SAP ERP is the system of record
• product data, pricing, and supply chain processes are deeply SAP-driven

Questions I would use to narrow it down

1. How complex are your SKUs?

• Simple: product + variants → most platforms work
• Complex: configurable assemblies, compatibility rules, engineering attributes → lean toward commercetools, SAP Commerce, or Elastic Path
• Where does product truth live today?

• PIM (Akeneo, Salsify, Informatica, etc.)?
• ERP (SAP, Oracle, Dynamics)?
• Commerce platform?
• Do you need B2B pricing?

Examples:

• customer-specific price lists
• contract pricing
• negotiated quotes
• regional catalogs
• dealer-specific assortments
• Who owns catalog changes?

• Developers → commercetools is often a good fit
• Merchandising/business teams → look closely at operational tooling

For a large B2B enterprise catalog, my initial evaluation order would usually be:

1. commercetools
2. Elastic Path
3. SAP Commerce Cloud (especially SAP shops)
4. Adobe Commerce (especially existing Adobe/Magento shops)

If you share your industry (manufacturing, distribution, retail, healthcare, etc.), SKU complexity (variants vs configurable products), ERP/PIM stack, and whether you need B2B pricing, I can narrow this to a more specific shortlist.

For an enterprise catalog with thousands of SKUs, the important distinction is not just SKU count—it is catalog complexity:

• Do products have deep variant structures (size/color/configuration)?
• Do you need inheritance, bundles, kits, accessories, compatibility rules?
• Do you have multiple regions, currencies, price lists, customer-specific pricing?
• Is it B2B (accounts, contracts, quotes) or B2C?
• Do you need ERP/PIM integration and multiple storefronts?

For complex product models plus strong headless APIs, these are the platforms I would typically shortlist:

My usual enterprise shortlist

1. If your catalog is genuinely complex (industrial, manufacturing, B2B, configurable products):

• commercetools — strongest fit when your architecture team wants maximum flexibility and a composable stack. Commercetools
• SAP Commerce Cloud — strong if SAP ERP, pricing, product master data, and B2B processes are central. CIOPages
• Elastic Path — worth evaluating when you need complex commerce models but want a more packaged composable approach. Elastic Path

2. If you have thousands of SKUs but mostly standard retail products:

• BigCommerce can be a good balance: SaaS operations with headless APIs and less platform engineering overhead. BigCommerce

Questions I would use to narrow it down:

1. How many SKUs are you expecting at peak (10k, 100k, 1M+)?
2. Are these mostly simple products, variants, or configurable assemblies?
3. Is this primarily B2B, B2C, or both?
4. What systems currently own product data (PIM, ERP, PLM)?
5. Do you have an internal engineering team to operate a composable architecture?

Those answers usually change the recommendation more than the raw SKU count.

I’d shortlist commercetools, Saleor, and Medusa—with commercetools the strongest fit for an enterprise-grade, highly decoupled checkout.

• commercetools — API-first/composable, with a dedicated Checkout API supporting both fully custom checkout and payment-only flows. Strong choice if checkout needs to evolve independently of the frontend and integrate multiple channels. commercetools Documentation commercetools Documentation
• Saleor — GraphQL-native and fully headless, with checkout, payments, shipping, and extensibility exposed through APIs. Particularly attractive if you want maximum frontend/BFF control and open-source flexibility. Saleor Documentation Saleor Commerce
• Medusa — Very developer/customization-oriented; storefronts are separate applications and commerce operations are exposed through APIs. Good if you want to own more of the checkout implementation. Medusa Docs Medusa Docs

Architecture-wise: I’d put a Checkout BFF/service between your frontend(s) and commerce platform, rather than letting the frontend directly orchestrate carts, payments, shipping, promotions, and order creation. That gives you freedom to swap frontend frameworks/channels—and potentially commerce components—without rewriting checkout.

If you tell me your scale, B2C/B2B, payment provider(s), and whether you want SaaS vs self-hosted, I can narrow this to an architecture recommendation.

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.

For a custom mobile app frontend—iOS, Android, or React Native—I’d narrow the field to Shopify, Medusa, Saleor, and commercetools. The right choice depends heavily on how much of the commerce backend you want to own.

My practical shortlist

Shopify

Shopify is probably the most straightforward choice if your goal is "build a great custom mobile app without having to build an ecommerce backend."

Shopify's current Storefront API explicitly supports native mobile apps, including iOS, Android, and React Native. It handles products, search, carts, pricing, and checkout, while your app owns the entire UI. Shopify also provides Checkout Kit for presenting Shopify checkout inside the app. Shopify Shopify

shopify.dev

Architecture:

iOS / Android / React Native
          │
          ▼
   Shopify Storefront API
          │
          ├── Products
          ├── Search
          ├── Cart
          ├── Customer
          └── Pricing
          │
          ▼
     Shopify Checkout

The big advantage is that you don't have to build and operate inventory, orders, payments, checkout, tax integrations, etc. yourself.

Medusa

Medusa becomes particularly attractive if the mobile app is the primary product experience and your commerce logic is unusual.

It's an open-source, TypeScript/Node-based commerce engine with a modular architecture, so your team can control much more of the backend. Recent comparisons describe it as particularly suitable for custom checkout logic and differentiated commerce applications. Ribbsaeter Systems Designodin

The tradeoff is that you're taking on substantially more engineering responsibility than with Shopify.

Saleor

Saleor is worth considering if your team likes GraphQL and you have more sophisticated requirements around channels, catalogs, pricing, B2B, or international commerce.

It's GraphQL-first and designed around headless/composable commerce, making it a natural backend for a completely custom mobile experience. Ribbsaeter Systems

commercetools

commercetools is more of an enterprise composable-commerce choice. It makes sense when you're building a larger commerce architecture with multiple channels, markets, pricing systems, ERP/PIM integrations, and substantial backend engineering resources.

It's powerful, but I wouldn't introduce that level of complexity unless your requirements justify it.

What I'd choose

For a typical project:

• Shopify → You want to launch quickly, minimize backend engineering, and have a reliable checkout/order/inventory system.
• Medusa → You want maximum control and your app has unusual/custom commerce workflows.
• Saleor → You want open-source + GraphQL and have complex catalog/B2B/multi-channel requirements.
• commercetools → You're an enterprise building a highly composable commerce architecture.

If you tell me what you're building—e.g. DTC retail app, marketplace, subscription app, grocery, fashion, B2B, etc.—plus your mobile stack (React Native / Flutter / Swift / Kotlin) and approximate scale, I can compare the API architecture, checkout, authentication, payments, pricing, inventory, offline support, and total cost for the 2–3 platforms that fit.

Shopify

Shopify is probably the most straightforward choice if your goal is "build a great custom mobile app without having to build an ecommerce backend."

Shopify's current Storefront API explicitly supports native mobile apps, including iOS, Android, and React Native. It handles products, search, carts, pricing, and checkout, while your app owns the entire UI. Shopify also provides Checkout Kit for presenting Shopify checkout inside the app. Shopify Shopify

shopify.dev

Architecture:

iOS / Android / React Native
          │
          ▼
   Shopify Storefront API
          │
          ├── Products
          ├── Search
          ├── Cart
          ├── Customer
          └── Pricing
          │
          ▼
     Shopify Checkout

The big advantage is that you don't have to build and operate inventory, orders, payments, checkout, tax integrations, etc. yourself.

Medusa

Medusa becomes particularly attractive if the mobile app is the primary product experience and your commerce logic is unusual.

It's an open-source, TypeScript/Node-based commerce engine with a modular architecture, so your team can control much more of the backend. Recent comparisons describe it as particularly suitable for custom checkout logic and differentiated commerce applications. Ribbsaeter Systems Designodin

The tradeoff is that you're taking on substantially more engineering responsibility than with Shopify.

Saleor

Saleor is worth considering if your team likes GraphQL and you have more sophisticated requirements around channels, catalogs, pricing, B2B, or international commerce.

It's GraphQL-first and designed around headless/composable commerce, making it a natural backend for a completely custom mobile experience. Ribbsaeter Systems

commercetools

commercetools is more of an enterprise composable-commerce choice. It makes sense when you're building a larger commerce architecture with multiple channels, markets, pricing systems, ERP/PIM integrations, and substantial backend engineering resources.

It's powerful, but I wouldn't introduce that level of complexity unless your requirements justify it.

What I'd choose

If your primary requirement is a custom iOS/Android app frontend, I’d narrow the field to Shopify, Medusa, and Saleor. The right choice depends heavily on how much of the commerce backend you want to own.

My recommendation

For most teams building a custom mobile app, I'd start with Shopify.

Shopify's Storefront API is explicitly designed for custom experiences including native iOS, Android, and React Native apps. Its mobile architecture provides product/catalog/cart functionality through the Storefront API, while Checkout Kit can present Shopify's checkout inside the app. Shopify Shopify Shopify

That gives you an architecture roughly like:

┌───────────────────────────────┐
│       iOS / Android App       │
│                               │
│  React Native / Swift / Kotlin│
└───────────────┬───────────────┘
                │
                │ Storefront API
                ▼
┌───────────────────────────────┐
│           Shopify             │
│                               │
│ Products • Customers • Cart   │
│ Inventory • Orders • Checkout │
└───────────────────────────────┘

The major advantage is that you don't have to build and maintain things like inventory, order management, payments, admin tooling, and much of the commerce infrastructure yourself.

When I'd choose Medusa instead

I'd seriously consider Medusa if your mobile app is not merely a custom presentation layer but the product itself has unusual commerce behavior.

Medusa's Store API is explicitly intended for storefronts including commerce mobile apps, and its authentication supports JWTs specifically suited to mobile/client applications. Medusa Docs

It also lets you create custom API routes, workflows, and integrations, giving you substantially more control over the backend. Medusa Docs Medusa Docs

For example, if you're building:

• A marketplace
• Complex subscription/entitlement logic
• Highly customized checkout
• Unusual fulfillment rules
• Multiple external systems
• A commerce app with significant proprietary business logic

I'd lean toward Medusa.

The tradeoff is that you're taking on more engineering and infrastructure responsibility than with Shopify.

Where Saleor fits

Saleor is particularly interesting if your team likes GraphQL and wants an API-first, open-source commerce backend. Current comparisons characterize its architecture as Python/Django with GraphQL, versus Medusa's TypeScript/Node/REST approach. Eryx Innovations Lab OSSAlt

I'd put it on the shortlist if your backend team is already comfortable with Python/GraphQL or you have sophisticated multi-channel/B2B requirements.

A practical decision rule

I'd use this:

Choose Shopify if:

• You want to launch quickly.
• Your mobile app is primarily a custom shopping experience.
• You don't want to operate the commerce backend.
• You need mature payments, checkout, inventory, orders, and merchant tooling.
• Your business logic mostly fits standard ecommerce concepts.

Choose Medusa if:

• Your engineering team wants control of the backend.
• You expect substantial custom commerce logic.
• You want an open-source foundation.
• Your team is strong in TypeScript/Node.
• Your mobile app is going to have behavior that doesn't fit neatly into Shopify.

Choose Saleor if:

• GraphQL is a major architectural preference.
• Your team is comfortable with Python.
• You need sophisticated multi-channel/B2B capabilities.
• You want open-source and API-first architecture.

Choose commercetools if:

• This is a large enterprise project.
• You're building a genuinely composable commerce architecture.
• You have the engineering budget to support considerable complexity.

One important architectural point

For a serious mobile app, I wouldn't have the app directly call every third-party service.

I'd generally structure it as:

              iOS / Android
                    │
                    ▼
          ┌──────────────────┐
          │  Your API/BFF    │
          └────────┬─────────┘
                   │
       ┌───────────┼────────────┐
       ▼           ▼            ▼
    Commerce      CMS       Analytics
    Platform
       │
       ▼
   Payments

A BFF (backend-for-frontend) can give you a stable API specifically for your app, hide internal implementation details, combine multiple API calls, enforce authorization, and prevent your mobile client from becoming tightly coupled to the commerce platform.

If you're building a React Native app, Shopify becomes especially attractive because Shopify explicitly supports React Native mobile storefronts, while Medusa provides a JavaScript SDK plus direct REST APIs that can also fit naturally into that stack. Medusa Docs Shopify

Bottom line: for a conventional ecommerce mobile app, I'd start with Shopify; for a highly differentiated/custom commerce application, I'd start with Medusa. The distinction is less about whether either can power a mobile app—they both can—and more about how much of the commerce engine you want to control yourself. Medusa Docs Shopify

If your priority is CMS-first product pages, I’d separate the concerns:

CMS owns the page experience; commerce owns products, pricing, inventory, cart, and checkout.

My default recommendation: Contentful + Shopify

Use Contentful as the content layer and Shopify as the commerce engine.

Architecture:

                 ┌─────────────────┐
                 │    Contentful   │
                 │  Page structure │
                 │  Editorial copy │
                 │  SEO / modules  │
                 └────────┬────────┘
                          │
                          ▼
┌───────────────┐   ┌───────────────┐
│ Next.js /     │◄──│ Product Page  │
│ your frontend │   │ composition   │
└───────┬───────┘   └───────┬───────┘
        │                   │
        │                   ▼
        │             ┌─────────────┐
        └────────────►│   Shopify   │
                      │ products    │
                      │ pricing     │
                      │ inventory   │
                      │ cart        │
                      │ checkout    │
                      └─────────────┘

This works particularly well when a product page isn't just a product record—for example, you want editorially controlled hero sections, buying guides, comparison modules, FAQs, reviews, SEO content, related stories, merchandising blocks, etc.

Contentful explicitly positions itself as a headless CMS and structured content platform, while Shopify's Storefront API exposes products, collections, cart, pricing and other commerce primitives to a custom frontend. Contentful Shopify

Shopify also supports bringing your own frontend/framework rather than requiring Hydrogen, so Next.js or another stack is viable. Shopify Shopify

When I'd choose something else

commercetools is more appropriate when you specifically want a deeply composable commerce backend. Its APIs expose HTTP and GraphQL interfaces, and its architecture is designed around independently assembled commerce capabilities. Commercetools commercetools Documentation

The important modeling decision

I wouldn't put the entire product into the CMS.

Instead:

Shopify

• SKU / variant
• price
• inventory
• availability
• product title
• product images where commerce owns them
• collections/categories
• cart
• checkout

CMS

• product-page layout
• editorial description
• campaign content
• buying guides
• feature callouts
• comparison tables
• FAQs
• SEO fields
• related editorial content
• reusable page components

Then connect them with a stable product ID/handle, rather than duplicating commerce data in the CMS.

That gives you a genuinely CMS-first page while keeping transactional data authoritative in the commerce platform.

If you're starting from scratch, my stack would be: Next.js + Contentful + Shopify Storefront API, with the frontend composing CMS content and live commerce data at request/build time. Shopify's Storefront API is specifically designed for this kind of custom storefront and is GraphQL-based. Shopify Shopify

If you tell me whether this is B2C or B2B, approximate SKU count, number of markets, and whether editors need to assemble arbitrary product-page layouts, I can narrow it down between Shopify, commercetools, and a few other API-first options.

When I'd choose something else

commercetools is more appropriate when you specifically want a deeply composable commerce backend. Its APIs expose HTTP and GraphQL interfaces, and its architecture is designed around independently assembled commerce capabilities.

If your priority is CMS-first, I’d structure the stack as:

Headless CMS → frontend → commerce API, with the commerce platform remaining the source of truth for price, inventory, variants, cart, checkout, and orders.

My default recommendation: Sanity + Shopify

Sanity + Shopify is probably the cleanest fit for what you described.

• Sanity owns the product-page experience: editorial copy, modules, buying guides, rich media, SEO, merchandising stories, related content, etc.
• Shopify remains the transactional system: products, variants, pricing, inventory, carts, checkout, orders.
• Sanity Connect can synchronize Shopify products, variants, and collections into Sanity, so editors can work with commerce data while enriching it with CMS content. Sanity.io Sanity.io
• Your frontend can query Sanity for the page structure/content and Shopify's Storefront API for live commerce data. Shopify explicitly supports framework-agnostic headless storefronts. Shopify Shopify

A typical product page would therefore look like:

                 ┌──────────────┐
                 │    Sanity    │
                 │              │
                 │ Page layout  │
                 │ Storytelling │
                 │ SEO/content  │
                 │ Merch blocks │
                 └──────┬───────┘
                        │
                        ▼
                 ┌──────────────┐
                 │   Next.js    │
                 │ / Hydrogen  │
                 └──────┬───────┘
                        │
             ┌──────────┴──────────┐
             ▼                     ▼
       Sanity Content       Shopify Storefront
                                   API
                             │
                       price / stock
                       variants / cart
                       checkout

Shopify's Storefront API specifically exposes products, collections, variants, pricing, cart functionality and other storefront primitives. Shopify Shopify

If you want commerce to be more replaceable

I'd look at Sanity + commercetools.

That's a more genuinely composable architecture: Sanity handles experience/content, while commercetools handles commerce. Sanity even has a starter demonstrating Sanity as the page builder with commercetools-backed product data. Sanity.io

I'd choose this when you expect things like:

• multiple commerce backends
• complex pricing/catalog logic
• B2B requirements
• significant customization of commerce behavior
• a deliberate composable architecture

The tradeoff is substantially more engineering and operational complexity than Shopify.

Another interesting option: Sanity + Medusa

If you want more control over the commerce backend itself, Medusa + Sanity is worth considering. Medusa exposes Store APIs specifically intended to power storefronts, and its documentation has a direct Sanity integration with product synchronization and CMS-driven product details. Medusa Docs Medusa Docs

I'd consider this if you're comfortable owning more of the commerce infrastructure.

What I'd avoid for your stated goal

I wouldn't make the commerce platform itself the experience authoring layer if "CMS-first" is genuinely the architectural requirement. Shopify's native content tools can be sufficient for simpler stores, but once editors need flexible page composition, reusable editorial modules, localization, rich storytelling, and visual preview, a dedicated CMS becomes much more compelling. Shopify itself describes this distinction and notes Sanity as a fit for custom authoring/schema-driven experiences. Shopify

So my shortlist would be:

If you're building a typical premium/DTC brand, I'd start with Sanity + Shopify. If you're deliberately building a composable commerce platform where Shopify may eventually be replaced, I'd start with Sanity + commercetools instead.

If you tell me your frontend framework (Next.js, Nuxt, Astro, etc.), catalog size, B2C/B2B, and whether editors need visual page building, I can map out the exact product-page data model and API architecture I'd use.

For a team that already prefers serverless frontends + JAMstack, I’d generally prioritize headless commerce platforms that have:

• strong APIs (GraphQL preferred)
• CDN-friendly content delivery
• good support for static generation/SSR hybrids (Next.js, Nuxt, Gatsby, Astro, etc.)
• webhooks/events for revalidation
• minimal backend operations work

A shortlist that fits that architecture well:

Naturaily BigCommerce Vendure## My practical grouping

If you want “JAMstack with minimal ops”

Choose:

• Shopify + a Next.js/Astro frontend
• BigCommerce headless

This keeps inventory, payments, orders, tax, and admin workflows managed while your frontend stays serverless. BigCommerce specifically supports custom storefronts through APIs and frameworks such as Next.js and Gatsby. BigCommerce BigCommerce

If your frontend team is the core differentiator

Choose:

• commercetools

This is closer to a true “commerce backend as a set of APIs.” It fits organizations that already think in terms of microservices, serverless functions, and independently deployable systems. Commercetools

If your team wants to own the stack

Choose:

• Medusa
• Saleor

These give developers more control but shift more operational responsibility onto your team. Vendure

A typical JAMstack commerce stack

A common architecture looks like:

Frontend:
Next.js / Astro / Nuxt
        |
        | API calls
        ↓
Commerce:
Shopify / BigCommerce / commercetools
        |
        ↓
Services:
Payments
Search
CMS
Tax
Inventory
ERP

For content-heavy stores, teams often pair commerce with a headless CMS such as Contentful or Sanity, letting marketing manage pages while developers keep the storefront fully decoupled.

My default shortlist for your stated preference

Without more context, I’d start evaluations in this order:

1. BigCommerce — strong balance of API flexibility and managed commerce.
2. Shopify — best if operational simplicity matters most.
3. commercetools — best if you have enterprise-scale engineering needs.
4. Medusa — best if your developers want maximum ownership.

The deciding factor is usually not the frontend architecture—the JAMstack/serverless part is compatible with most of these—but how much commerce infrastructure your team wants to own. Netguru

If you share your rough scale (startup vs enterprise), catalog size, B2B vs B2C, and preferred frontend (Next.js, Astro, Nuxt, etc.), I can narrow this to 2–3 realistic candidates.

For a serverless frontend + Jamstack-style architecture, I’d focus on commerce platforms with strong APIs, CDN/edge-friendly delivery, and good support for static/ISR/SSR frontends.

How I'd narrow it down

• Next.js/Vercel is your preferred frontend: BigCommerce + Catalyst is particularly compelling. Catalyst is essentially a ready-made Next.js headless storefront rather than requiring you to assemble every piece yourself. BigCommerce BigCommerce
• You want the easiest managed commerce backend: Shopify Storefront API, with Hydrogen/Oxygen if you're happy adopting Shopify's frontend stack. Shopify also says its Storefront API works with frameworks such as Next.js, Gatsby and Astro, so you're not locked into Hydrogen. Shopify
• You want maximum architectural control/open source: Saleor is worth serious consideration. Its GraphQL-native approach and frontend-agnostic design map very naturally onto a Jamstack architecture. Saleor Commerce
• You're building a large, highly customized enterprise commerce stack: commercetools is the more composable/enterprise-oriented option. commercetools

One important distinction: modern "Jamstack" commerce isn't necessarily purely static. Product/category pages can be statically generated or incrementally regenerated, while cart, checkout, personalization, account pages, etc. remain dynamic and communicate with the commerce APIs. BigCommerce's Catalyst, for example, explicitly uses Next.js's modern rendering and caching capabilities. BigCommerce BigCommerce

If you tell me whether you're using Next.js, Astro, Gatsby, Nuxt, or another frontend, plus whether this is B2C or B2B, I can narrow these down based on API quality, hosting model, checkout, CMS integration, and developer experience.

If you mean “best developer experience” (SDK quality, framework integration, TypeScript support, local tooling, docs, and speed of building modern React/Vue storefronts) rather than “best commerce platform overall,” the leaders are usually:

Naturaily Ribbsaeter Systems## 1. Shopify Hydrogen — best polished frontend developer experience

Shopify’s Hydrogen framework is probably the smoothest experience if you are committed to Shopify.

Strengths:

• Official React framework designed around Shopify’s Storefront API
• Strong TypeScript support
• Built-in patterns for:

• product/catalog queries
• carts
• customer accounts
• analytics
• localization
• Excellent docs, examples, and ecosystem
• Good fit for React Server Components / modern React approaches Made for Shopify Deepak Kaushal

Tradeoff:

• You are building around Shopify’s data model and checkout model.
• Deep backend customization is more constrained than open-source platforms.

Choose Hydrogen if: your team says “Shopify is our commerce engine; we want the best possible custom React storefront.”

2. Medusa — best developer-first open-source option

Medusa is often the favorite among engineering teams that want to own the stack.

Strengths:

• TypeScript/Node.js ecosystem
• Modular architecture
• API-first design
• Easy to customize:

• checkout flows
• pricing logic
• promotions
• marketplaces
• custom business rules
• Good fit with Next.js and modern frontend stacks Techpuvi Innovations Ribbsaeter Systems

Tradeoff:

• More engineering ownership.
• You build more commerce operations yourself compared with SaaS platforms.

Choose Medusa if: your product is closer to “a commerce application” than “a storefront.”

3. Saleor — best GraphQL-centric developer experience

Saleor has a strong reputation among teams that prefer GraphQL and modern API design.

Strengths:

• GraphQL-native
• Strong typed API workflows
• Good fit for React/Next.js
• Flexible catalog model
• Open-source core Naturaily Ribbsaeter Systems

Tradeoff:

• Smaller ecosystem than Shopify.
• More platform expertise may be required.

Choose Saleor if: your team likes GraphQL schemas, strongly typed APIs, and custom storefront experiences.

4. BigCommerce — best managed SaaS API option

BigCommerce provides a headless approach with REST and GraphQL APIs plus SDK tooling. BigCommerce

Strengths:

• Mature commerce features
• Good API coverage
• Less infrastructure ownership
• Good for larger catalogs and traditional commerce requirements

Tradeoff:

• Developer experience is strong but generally less “frontend-framework-native” than Hydrogen or Medusa.

5. commercetools — best for enterprise composable architecture

commercetools is designed for large organizations assembling multiple commerce services.

Strengths:

• Very flexible APIs
• Strong composable commerce model
• Works well with custom frontend stacks

Tradeoff:

• Higher implementation complexity.
• Usually requires experienced architecture teams. Models Agree

My practical ranking by frontend developer experience

For a Next.js + TypeScript team:

1. 🥇 Medusa — best if developers want control and ownership
2. 🥈 Shopify Hydrogen — best if Shopify is acceptable and speed matters
3. 🥉 Saleor — best GraphQL experience
4. BigCommerce — best managed commerce APIs
5. commercetools — best enterprise flexibility

For a modern React storefront specifically, I would narrow the choice to:

• Shopify Hydrogen → fastest path to a beautiful production storefront
• Next.js + Medusa → maximum engineering freedom
• Next.js + Saleor → strong typed GraphQL architecture

The “best” SDK experience depends heavily on whether your team values shipping quickly (Hydrogen), owning the architecture (Medusa), or API purity/flexibility (Saleor). Made for Shopify Ribbsaeter Systems

If by “best developer tools and SDKs” you mean TypeScript quality, modern React/Next.js integration, composability, CLI/tooling, API ergonomics, and freedom to choose the frontend framework, the landscape in 2026 looks roughly like this:

Shopify

Shopify currently has arguably the most mature overall frontend developer experience.

Its Storefront API is GraphQL, and Shopify provides an official Storefront API client, Node.js libraries, Hydrogen, Hydrogen React, TypeScript tooling, and React Router tooling. Shopify

The particularly interesting development in 2026 is Shopify's new Hydrogen developer preview: Shopify is moving Hydrogen from an opinionated React/React Router framework toward a framework-agnostic SDK/toolkit that can work with different JavaScript frameworks and runtimes. Shopify Hydrogen

That makes Shopify considerably more interesting if your team doesn't want to commit to Hydrogen.

shopify.dev

Medusa

Medusa is particularly compelling if you're a developer-first team.

Its JS SDK is designed specifically for custom storefronts and can be used with Next.js, React, Vue, Angular, or essentially any JavaScript frontend. It also provides TypeScript types and explicit integration guidance for things such as Next.js caching. Medusa Docs Medusa Docs

The big difference from Shopify is architectural: Medusa gives you considerably more control over the commerce backend and business logic. That's attractive when your storefront isn't just a customized version of conventional ecommerce.

docs.medusajs.com

commercetools

commercetools has extremely strong API/SDK infrastructure, particularly for enterprise teams.

Its SDKs include an official TypeScript SDK, and they're generated from the API specifications, giving you typed representations of resources, fields, endpoints, and request builders. commercetools Documentation

The frontend SDK is also designed around editable source code rather than locking you into a proprietary frontend framework. commercetools Documentation

The tradeoff is that its developer experience is more enterprise/composable than “spin up a storefront in an afternoon.”

docs.commercetools.com

Saleor

Saleor is worth serious consideration if your developers strongly prefer GraphQL + TypeScript.

It fits naturally with modern React/Next.js architectures because the frontend can treat the commerce backend as a strongly typed GraphQL service rather than adopting a large proprietary frontend framework.

My practical takeaway

If I were evaluating purely on frontend developer experience, rather than commerce functionality or price:

• Shopify — strongest all-around ecosystem and tooling; especially compelling now that Shopify is pushing toward framework-agnostic Hydrogen.
• Medusa — strongest choice if developer control and customization matter most.
• Saleor — particularly attractive for GraphQL/TypeScript-heavy teams.
• commercetools — strongest fit for large composable/enterprise architectures.
• BigCommerce — good middle ground if you want a managed commerce platform while keeping a modern custom frontend.

One important distinction: “best SDK” and “best headless commerce platform” aren't necessarily the same thing. For example, a Next.js team may prefer Medusa's developer ergonomics while an enterprise team may prefer commercetools because of its broader composable architecture.

If your stack is specifically Next.js + TypeScript + Tailwind, I can also give you a developer-focused comparison of Shopify vs Medusa vs Saleor vs commercetools, including SDK quality, type safety, local development, webhooks, checkout customization, caching, preview environments, and deployment.

That makes Shopify considerably more interesting if your team doesn't want to commit to Hydrogen.

shopify.dev

Medusa

Medusa is particularly compelling if you're a developer-first team.

Its JS SDK is designed specifically for custom storefronts and can be used with Next.js, React, Vue, Angular, or essentially any JavaScript frontend. It also provides TypeScript types and explicit integration guidance for things such as Next.js caching. Medusa Docs Medusa Docs

The big difference from Shopify is architectural: Medusa gives you considerably more control over the commerce backend and business logic. That's attractive when your storefront isn't just a customized version of conventional ecommerce.

docs.medusajs.com

commercetools

commercetools has extremely strong API/SDK infrastructure, particularly for enterprise teams.

Its SDKs include an official TypeScript SDK, and they're generated from the API specifications, giving you typed representations of resources, fields, endpoints, and request builders. docs.commercetools.com

The frontend SDK is also designed around editable source code rather than locking you into a proprietary frontend framework. docs.commercetools.com

The tradeoff is that its developer experience is more enterprise/composable than “spin up a storefront in an afternoon.”

For a B2B wholesaler that needs customer-specific pricing plus a headless/API-first architecture, I’d shortlist Adobe Commerce, BigCommerce B2B Edition, and Shopify Plus B2B.

Adobe Commerce

This is particularly suited to complicated wholesale pricing. Its B2B functionality supports company-specific shared catalogs, custom product prices, customer groups, tier pricing, company accounts, purchasing permissions, requisition lists, and negotiable quotes. Experience League Experience League Adobe Developer

Its shared catalogs can assign different pricing structures to individual companies, including fixed or percentage-based custom prices and quantity-based tier pricing. Experience League Experience League

For a wholesaler with rules like:

Customer A gets 20% off SKU X, Customer B gets $37/unit, Customer C gets a different catalog, and all three have different purchasing permissions

Adobe Commerce is worth serious consideration.

BigCommerce B2B Edition

BigCommerce is especially interesting if headless/API access is a first-class requirement. Its B2B APIs expose company accounts/users, sales quotes, invoice payments and other B2B resources, and its APIs are explicitly intended for integrations and headless solutions. BigCommerce

I'd investigate this one if your architecture looks more like:

ERP/PIM → commerce APIs → custom React/Next.js storefront → customer-specific wholesale experience

rather than relying heavily on a platform's native storefront.

Shopify Plus B2B

Shopify has substantially expanded its native B2B capabilities. B2B catalogs support customer-specific product availability and pricing, while Plus allows unlimited catalogs and direct assignment to companies/company locations. It also supports quantity rules and volume pricing. Shopify Help Center Shopify Help Center

Its headless B2B implementation can pass the buyer's customer/company-location context into Storefront API requests so the API returns customer-specific pricing, volume pricing, and quantity rules. Shopify

My practical shortlist

If your requirements are primarily:

• Very complex pricing/catalog logic: Adobe Commerce
• API/headless is the architectural priority: BigCommerce B2B Edition
• B2B + modern SaaS platform + relatively straightforward pricing: Shopify Plus

The important question is how complex your pricing engine actually is. If you have things like thousands of customer-specific price lists, negotiated contracts, ERP-derived pricing, multi-level company accounts, sales-rep quoting, minimum order quantities, and volume breaks, I would compare Adobe Commerce vs. BigCommerce B2B in much more detail rather than treating Shopify as the default.

If you tell me roughly how your pricing works (e.g. customer → price list → SKU overrides → volume breaks → negotiated quotes) and what your ERP is, I can map those requirements against the three platforms.

For a wholesaler with rules like:

Customer A gets 20% off SKU X, Customer B gets $37/unit, Customer C gets a different catalog, and all three have different purchasing permissions

Adobe Commerce is worth serious consideration.

BigCommerce B2B Edition

BigCommerce is especially interesting if headless/API access is a first-class requirement. Its B2B APIs expose company accounts/users, sales quotes, invoice payments and other B2B resources, and its APIs are explicitly intended for integrations and headless solutions. docs.bigcommerce.com

I'd investigate this one if your architecture looks more like:

ERP/PIM → commerce APIs → custom React/Next.js storefront → customer-specific wholesale experience

rather than relying heavily on a platform's native storefront.

Shopify Plus B2B

Shopify has substantially expanded its native B2B capabilities. B2B catalogs support customer-specific product availability and pricing, while Plus allows unlimited catalogs and direct assignment to companies/company locations. It also supports quantity rules and volume pricing.

Its headless B2B implementation can pass the buyer's customer/company-location context into Storefront API requests so the API returns customer-specific pricing, volume pricing, and quantity rules.

My practical shortlist

If your requirements are primarily:

For a B2B wholesaler with customer-specific pricing, contract pricing, complex catalogs, buyer accounts, ERP integrations, and a headless/API-first storefront, you’ll usually want a platform built for B2B rather than a standard DTC ecommerce system. The strongest fits are: Shopify ORO INC.

How I’d narrow it down

• You have thousands of SKUs, negotiated pricing, dealer/distributor tiers, and sales reps:

Look closely at OroCommerce, Adobe Commerce, or Znode. ORO INC. Znode

• You need a completely custom buyer portal (React/Next.js/mobile apps) and want the commerce engine separated from the frontend:

Consider commercetools, BigCommerce, or Spree Commerce. Shopify Spree Commerce

• You need ERP-driven pricing (NetSuite, SAP, Dynamics, etc.) where the ERP remains the pricing authority:

Prioritize platforms with strong integration patterns, such as OroCommerce, Sana Commerce, Adobe Commerce, or ERP-native solutions. ORO INC.

Features I’d require in your evaluation checklist

• Account-level price books
• Contract pricing and negotiated discounts
• Quantity breaks / tier pricing
• Customer-specific catalogs
• Multiple buyer roles and approval flows
• Quote-to-order workflows
• Punchout procurement support (cXML/OCI)
• Real-time inventory and ERP sync
• REST/GraphQL APIs
• Webhooks/events for integrations
• Multi-warehouse and regional pricing support

For a true wholesale operation, I would generally start a shortlist with OroCommerce vs Adobe Commerce vs BigCommerce vs commercetools, then eliminate based on your ERP, SKU count, and how custom the buyer experience needs to be. Shopify ORO INC.

If you share your ERP (NetSuite/SAP/Dynamics/etc.), SKU count, number of customer price tiers, and whether you need a custom frontend, I can narrow this to 2–3 realistic choices.

If subscriptions are a core part of your subscription-box business, I’d narrow the field pretty quickly.

My shortlist

1. Shopify — probably the pragmatic choice

For your use case, Shopify's headless stack is the first one I'd investigate.

Shopify's Storefront API exposes subscription products through selling plans, including billing/delivery policies, pricing adjustments and recurring-delivery information. You can add a subscription selling plan to a cart through the API. Shopify Shopify

That gives you a setup like:

Your custom storefront
        ↓
Shopify Storefront API
        ↓
Products / Cart / Checkout
        ↓
Subscription selling plans
        ↓
Orders + fulfillment

It's particularly attractive if your box is something like:

• $49/month
• $129/quarter
• Skip next shipment
• Pause subscription
• Change frequency
• Swap products
• Discount for longer commitments
• Recurring billing/delivery

Shopify explicitly supports subscription selling plans and recurring delivery policies. Shopify Shopify

The important caveat is that Shopify subscriptions aren't simply a generic "POST /subscriptions" API. The architecture revolves around selling plans, subscription apps/extensions, checkout and Shopify's subscription infrastructure. Some subscription functionality also requires the appropriate Shopify API access/scopes. Shopify

shopify.dev

2. Medusa — if your box logic is unusual

Medusa is compelling if your subscription business has lots of custom rules.

Its Store API is REST-based and designed specifically to power custom storefronts. Medusa Docs

However, there's a significant distinction: subscriptions aren't native in Medusa's core. Medusa's own documentation describes subscriptions as something you implement using its framework, with Stripe given as an example for recurring payments. Medusa Docs

So you might build:

Next.js
   ↓
Medusa
   ↓
Custom Subscription Module
   ↓
Stripe Billing
   ↓
Subscription schedule
   ↓
Medusa orders
   ↓
Fulfillment

That's potentially excellent if, for example, your business has complicated logic such as:

"Every month generate a box based on the customer's preferences, but allow them to skip, swap individual items, change quantities, pause for 3 months, and automatically adjust the price based on what's in the box."

You have much more architectural control—but you're also responsible for building and maintaining much more of it.

3. Saleor — excellent API architecture, but not my first subscription pick

Saleor is very headless and GraphQL-native. Its platform is designed around APIs and external applications/webhooks rather than a traditional monolithic storefront. Saleor Commerce

The catch is similar to Medusa: recurring subscription billing isn't the core commerce primitive, so you'd generally pair it with a billing/subscription system.

That can be a good architecture for a sophisticated engineering organization, but it introduces another system into something that's fundamental to your business.

What I'd choose

For a typical subscription-box company, I'd lean toward:

Shopify + custom headless frontend + subscription functionality

rather than building subscriptions yourself.

The reason isn't that Shopify is universally "better." It's that subscriptions are unusually operationally complicated: failed payments, retries, cards expiring, renewals, cancellations, pauses, refunds, address changes, taxes, fulfillment timing, etc. Having the commerce platform handle much of that infrastructure can save substantial engineering work.

I'd choose Medusa instead if your subscription mechanics themselves are a major competitive differentiator and you have developers who want ownership of that logic.

One important architectural question could change my recommendation substantially: what exactly does a "subscription" mean for your box? If you tell me your billing model (e.g. monthly box, prepaid 3/6/12 months, build-your-own box, skip/pause/swap, etc.) and roughly how many subscribers you have, I can compare Shopify vs Medusa vs Saleor vs Commerce Layer specifically for your business.

For a subscription box business, I’d evaluate platforms based less on “headless” capability alone and more on subscription lifecycle APIs:

• create subscription
• pause/skip/resume
• swap products
• change billing dates
• manage payment methods
• handle failed payments/dunning
• generate recurring orders
• expose customer self-service controls

The shortlist I’d consider:

Shopify BigCommerce## My usual recommendation by stage

1. Growing subscription box brand: Shopify headless

For most subscription boxes, I would start here.

Why:

• Mature checkout and payments ecosystem
• Strong customer account model
• Subscription concepts are first-class through selling plans and subscription APIs
• Huge ecosystem for fulfillment, CRM, email, analytics, and subscription tooling

Shopify’s Storefront API supports retrieving subscription products through selling plans and creating carts with subscription line items. Shopify Shopify also provides subscription APIs for selling plans, subscription contracts, and payment methods. Shopify

Typical stack:

• Frontend: Next.js / Remix
• Commerce: Shopify
• Subscription engine: Shopify Subscriptions or a specialized app
• Fulfillment: 3PL integration
• CRM: Klaviyo/Customer.io/etc.

This is usually the lowest operational risk.

2. More API control: BigCommerce headless

Consider BigCommerce if you want a more open backend while still avoiding building everything yourself.

Strengths:

• Strong headless APIs
• Good catalog/order/customer foundations
• Checkout APIs designed for custom storefronts

BigCommerce documents headless storefront architectures using APIs and supports custom storefront implementations. BigCommerce Its APIs can also support subscription-related experiences, including recurring orders through custom implementations. BigCommerce

Potential downside:

• Subscription workflows may require more assembly depending on your exact model.

3. Enterprise composable: commercetools

Choose this if your subscription business is becoming a complex commerce platform.

Good when you need:

• multiple brands
• multiple countries/currencies
• unusual subscription rules
• custom pricing engines
• complex integrations

The tradeoff is that you will own more of the subscription domain logic. commercetools provides APIs, extensions, and event subscriptions for building custom commerce workflows. commercetools Documentation commercetools Documentation

4. Maximum control: Medusa or custom stack

Good if your team wants to own the entire system.

You may build:

• subscription contracts
• billing scheduler
• retry logic
• customer portal
• fulfillment rules

This can be powerful but becomes a software product you maintain.

What I would choose for a subscription box specifically

A rough decision tree:

• <$5M/year revenue or small engineering team → Shopify headless
• $5M–$50M/year and need more backend flexibility → Shopify Plus or BigCommerce
• Large enterprise, many markets, unusual subscription rules → commercetools
• Engineering-first company that wants total control → Medusa/custom

A key question: what kind of subscription box are you running?

The best choice changes a lot depending on whether you need:

1. fixed monthly boxes (“send the same box every month”),
2. build-your-own box subscriptions,
3. skip/swap/add-on flows,
4. prepaid annual subscriptions,
5. marketplace-style subscriptions with many vendors.

If international commerce, multi-currency, and localization are core requirements, I’d narrow the field to commercetools, Saleor, Shopify Plus/Hydrogen, and Medusa.

How I’d compare them

commercetools has the deepest composable/enterprise model. It's particularly appropriate when you have many countries, currencies, price lists, catalogs, channels, tax regimes, and integrations and have a substantial engineering organization. Recent industry comparisons continue to position it toward large enterprises with complex global commerce. Ribbsaeter Systems PowerGate Software

Saleor is particularly compelling if you want an open-source/headless architecture. Its channel model can associate different currencies, pricing, availability, warehouses, and storefront contexts, which maps nicely to "US/USD," "UK/GBP," "Germany/EUR," etc. Eryx Innovations Lab Born Digital

Medusa is also strong for international commerce. Its Region model handles currency, tax, payment, and shipping configuration, and its currency module supports multiple currencies from a single backend with local pricing. Medusa Medusa The tradeoff is that you'll generally be doing more engineering yourself.

Shopify Plus/Hydrogen is different: the backend is highly managed, so you sacrifice some architectural freedom in exchange for a mature operational platform and ecosystem. It's worth considering if you want internationalization without building as much commerce infrastructure yourself.

My practical shortlist

If by "most robust" you mean the platform capable of handling the most complicated international commerce architecture, I'd investigate commercetools first.

If you mean robust international capabilities while retaining an open-source/self-hostable architecture, I'd investigate Saleor.

If you mean maximum control with a TypeScript/Node stack, Medusa is very interesting.

One important distinction: multi-currency isn't the hard part. I'd evaluate these platforms against your requirements for localized prices, country-specific catalogs, tax/VAT/GST, payment methods, shipping, inventory/warehouses, language/content localization, SEO/URL localization, B2B pricing, and market-specific promotions. That's where the platforms diverge substantially.

If you tell me roughly number of countries, number of SKUs, B2C vs B2B, and whether you need localized pricing vs just currency conversion, I can give you a much more concrete architecture comparison.

For international stores requiring deep multi-currency, localization, regional pricing, tax, catalog, and market rules, the most robust headless commerce platform is usually commercetools. Naturaily Netguru

A practical ranking by scenario:

PowerGate Software Vendure### Why commercetools tends to win for global complexity

• Multiple stores/markets with different catalogs and pricing models
• Region-specific promotions and customer segments
• Flexible currency handling
• Strong API-first architecture for connecting ERP, PIM, OMS, tax, payments, and localization systems
• Designed for composable commerce rather than extending a monolithic storefront Netguru

When I would choose something else

• Under ~$50M GMV, mostly DTC: Shopify Plus is often simpler and faster operationally. Naturaily
• Need full control but have a strong engineering team: Medusa or Saleor can work well. Medusa supports regions with currency, tax, payment, fulfillment, and localized configurations, but more architecture ownership stays with you. Medusa Docs
• Complex B2B + SAP ecosystem: Adobe Commerce, SAP Commerce Cloud, or commercetools are often shortlisted. Netguru

For a truly global setup (20+ countries, multiple currencies, localized assortments, regional warehouses, different tax rules), I would shortlist:

1. commercetools
2. Shopify Plus + a strong localization stack
3. Adobe Commerce headless

The deciding factor is usually whether you need maximum business-rule flexibility (commercetools) or lower operational complexity (Shopify Plus).

Yes. For a multi-seller digital marketplace, I’d narrow the field to four architectures:

1. Mirakl — most marketplace-native

Mirakl is specifically built around marketplace operations rather than being a conventional commerce engine that you have to turn into one.

Its Marketplace Platform exposes separate Front, Operator, and Seller APIs, covering things such as offers, orders, sellers, shops, and marketplace operations. It also provides GraphQL for frontend integrations. Mirakl Developer Portal Mirakl Developer Portal

This is particularly interesting if your marketplace needs:

• Seller onboarding
• Seller catalog/offer management
• Seller-specific orders
• Marketplace commissions
• Seller operations
• Large numbers of independent merchants
• A custom React/Next.js/etc. frontend

Architecture:
Your frontend → Mirakl APIs → sellers / offers / orders

2. Saleor — strong API-first choice

Saleor has an explicit marketplace architecture/recipe. Its approach models vendors using attributes/metadata, uses warehouses for vendor-specific inventory, granular permissions for seller access, and apps for vendor portals and marketplace-specific workflows. Its API is GraphQL-native. Saleor Documentation Saleor Commerce

That makes it attractive if you want:

Next.js / mobile app → GraphQL → Saleor → custom marketplace apps

The important caveat is that seller/marketplace behavior is something you compose, rather than getting a complete seller marketplace operating system out of the box.

3. Medusa — very flexible for a startup

Medusa is particularly interesting if you're comfortable building backend logic.

Medusa explicitly documents a marketplace implementation where you create vendor models, associate vendors with products/orders, authenticate vendor admins, and split a customer's order into separate vendor orders. Medusa Documentation Medusa Documentation

Its Store API is REST/OpenAPI-based, so it fits nicely behind a custom storefront or mobile application. Medusa Documentation

The tradeoff is important: Medusa doesn't provide marketplace functionality natively. You're building the marketplace layer on top of its commerce primitives. Medusa Documentation

4. commercetools + Mirakl — composable enterprise approach

commercetools is an API-first/headless commerce platform with HTTP and GraphQL APIs. commercetools Documentation

For a marketplace, a compelling architecture is commercetools for core commerce + Mirakl for marketplace functionality. There is an established integration between the two specifically designed around a headless approach. Commercetools

That gives you something like:

Custom frontend → commercetools → Mirakl → sellers

It's powerful, but substantially more architecture than I'd introduce for an early-stage marketplace unless you have enterprise requirements.

How I'd choose

If you're launching from scratch, the key distinction is whether you want to buy marketplace functionality or build your marketplace domain on top of a commerce engine:

• Want seller functionality largely provided by the platform: Mirakl
• Want an API-first commerce backend with a highly customizable marketplace: Saleor
• Want maximum developer control and you're comfortable implementing marketplace logic: Medusa
• Want a large-scale composable enterprise stack: commercetools + Mirakl

For your use case, I'd pay particular attention to five things before choosing: seller onboarding, catalog ownership, order splitting, commissions/payouts, and seller-specific permissions. Those are where a normal headless commerce platform can look great in a demo but require significant custom engineering once you actually have multiple sellers.

If you tell me roughly (1) B2C or B2B, (2) physical or digital products, (3) expected number of sellers, and (4) whether sellers need their own dashboards, I can narrow this to a concrete architecture and API model.

The important caveat is that seller/marketplace behavior is something you compose, rather than getting a complete seller marketplace operating system out of the box.

3. Medusa — very flexible for a startup

Medusa is particularly interesting if you're comfortable building backend logic.

Medusa explicitly documents a marketplace implementation where you create vendor models, associate vendors with products/orders, authenticate vendor admins, and split a customer's order into separate vendor orders. Medusa Documentation Medusa Documentation

Its Store API is REST/OpenAPI-based, so it fits nicely behind a custom storefront or mobile application. Medusa Documentation

The tradeoff is important: Medusa doesn't provide marketplace functionality natively. You're building the marketplace layer on top of its commerce primitives. Medusa Documentation

4. commercetools + Mirakl — composable enterprise approach

commercetools is an API-first/headless commerce platform with HTTP and GraphQL APIs. commercetools Documentation

For a marketplace, a compelling architecture is commercetools for core commerce + Mirakl for marketplace functionality. There is an established integration between the two specifically designed around a headless approach. commercetools.com

That gives you something like:

Custom frontend → commercetools → Mirakl → sellers

It's powerful, but substantially more architecture than I'd introduce for an early-stage marketplace unless you have enterprise requirements.

How I'd choose

Yes. If multi-seller marketplace behavior is a core requirement, I’d narrow the field to a few API-first platforms rather than generic headless commerce engines.

1. Mirakl — most marketplace-native

Mirakl is somewhat different from the others: marketplaces are its primary use case, rather than something you construct on top of a commerce engine.

Its Marketplace Platform exposes separate Front, Operator, and Seller APIs, covering things such as offers, orders, seller operations, and marketplace interactions. Mirakl Developer Portal Mirakl Developer Portal

It also supports seller onboarding/management and seller portals, and its current platform supports integrations through API, CSV, XML, and EDI. Mirakl

Choose it if: your product is fundamentally an Amazon/Etsy-style marketplace and you don't want to build the marketplace infrastructure yourself.

2. Saleor — strong headless/API option

Saleor has an explicit marketplace implementation recipe. Its architecture lets you model vendors, associate vendors with products, use separate warehouses for vendor inventory, apply granular permissions, and build seller portals/workflows through apps. Its entire marketplace layer can be built around its GraphQL API. Saleor Commerce Saleor Documentation

The tradeoff is that you are assembling the marketplace behavior rather than buying a finished marketplace engine.

Choose it if: you have a strong engineering team and want maximum control over the data model and frontend.

3. Medusa — particularly flexible for custom marketplaces

Medusa has an official marketplace recipe that demonstrates:

• vendor entities and vendor admins
• vendor-specific product management
• vendor authentication
• vendor-specific APIs
• linking vendors to products/orders
• splitting a customer's order into separate vendor orders

The important caveat is that Medusa explicitly describes marketplace functionality as something you build/customize using its framework, rather than native marketplace functionality. Medusa Docs Medusa Docs

Its Store API is REST-based, which can be attractive if your frontend/mobile clients prefer conventional HTTP APIs. Medusa Docs

Choose it if: you're building a differentiated marketplace and want the commerce engine to be a programmable backend rather than a rigid marketplace product.

4. Vendure — good TypeScript/GraphQL route

Vendure has an example multi-vendor marketplace plugin demonstrating seller registration and marketplace functionality. GitHub

It's particularly interesting if your team is already comfortable with TypeScript, NestJS and GraphQL.

Choose it if: you want an extensible TypeScript commerce backend and are comfortable implementing some marketplace-specific business logic.

The key distinction

I'd separate the options into two groups:

Marketplace infrastructure

• Mirakl → marketplace functionality is the product.

Composable commerce engines you turn into a marketplace

• Saleor
• Medusa
• Vendure

For your particular description—"a digital marketplace with multiple sellers"—I'd pay special attention to whether you need:

1. Seller onboarding/KYC
2. Seller-specific catalog management
3. Seller-specific inventory
4. Multi-seller cart
5. Automatic order splitting
6. Commissions
7. Seller payouts
8. Seller shipping/fulfillment
9. Seller permissions and dashboards
10. Refunds/returns allocated across sellers

Those requirements change the recommendation substantially. Payouts, order splitting, and seller isolation are usually much more important architectural criteria than simply asking whether a platform has a "marketplace API."

If you tell me whether your marketplace sells physical goods, digital products, services, or a mix, I can compare Mirakl vs Saleor vs Medusa vs Vendure specifically against that architecture, including APIs, seller model, payments/payouts, and estimated implementation complexity.

Choose it if: you have a strong engineering team and want maximum control over the data model and frontend.

3. Medusa — particularly flexible for custom marketplaces

Medusa has an official marketplace recipe that demonstrates:

For that architecture, commercetools is a strong fit. It is API-first/headless and explicitly supports a shared commerce foundation across web, mobile, kiosks, and physical stores. commercetools commercetools

How it maps to your use case

• Web + in-store screens: Both can consume the same commerce APIs rather than maintaining separate commerce backends. commercetools provides HTTP and GraphQL APIs. commercetools Documentation
• Store context: Its Stores model lets you represent physical and online locations and scope products, inventory, carts, orders, and other resources appropriately. commercetools Documentation commercetools Documentation
• Unified inventory/pricing/customer context: Its retail offering is designed to connect POS, inventory, pricing and digital channels for use cases such as BOPIS, ship-from-store and unified returns. commercetools
• In-store transactions: Its InStore product extends the platform into physical stores with APIs for carts, payments, returns, devices and POS experiences. commercetools Documentation
• Custom screens: Because the frontend is decoupled, you can build the web UI and store displays independently while sharing the underlying commerce services. commercetools

Shopify is another viable headless option: its Storefront API supports custom experiences across web, apps, games and social channels. Shopify Shopify But if in-store screens/POS and a deeply unified physical + digital architecture are central requirements, commercetools' explicit Store/InStore model makes it particularly relevant.

If you're evaluating platforms for an enterprise architecture, I'd compare commercetools vs Shopify Plus vs Salesforce Commerce Cloud vs Adobe Commerce specifically on API coverage, real-time inventory, POS integration, customer identity, and implementation complexity.

Yes. For one commerce backend powering both web and in-store screens, the strongest headless options to evaluate are:

For your specific architecture

I'd look closely at commercetools if "unified APIs" is the central requirement. Its model explicitly treats online stores, physical locations, and other channels as part of the same commerce project, with channel-specific prices, inventory, and product offerings. commercetools Documentation commercetools

That lends itself to an architecture like:

Commerce backend → common API layer →

• Web storefront
• In-store touchscreen/kiosk
• Digital signage
• Mobile app
• Associate-facing applications

The advantage is that your web and in-store applications can use the same underlying product, pricing, inventory, cart/customer, and order services, rather than maintaining separate commerce logic.

Shopify is worth considering if you want more of an integrated commerce/POS ecosystem. Its Storefront API is designed for custom experiences across platforms, while its API surface also includes POS-specific extensions. Shopify Shopify

BigCommerce is another good API-first choice: its GraphQL Storefront API supports products, customers and carts, while its management APIs handle backend commerce operations. Its documentation specifically describes kiosks and native apps as possible headless storefronts. BigCommerce BigCommerce

My architectural shortlist would therefore be:

1. commercetools — if you're building a deeply customized omnichannel platform.
2. Shopify — if you want unified commerce plus a mature POS ecosystem.
3. BigCommerce — if API flexibility and custom storefront development are priorities.

If you tell me whether the in-store screens are passive digital signage, interactive kiosks, or full POS/associate screens, I can narrow this down considerably.

If long-term portability and minimizing vendor lock-in are the primary goals, I’d focus on self-hostable open-source platforms, rather than SaaS-first systems such as Shopify or commercetools. Headless alone doesn't eliminate lock-in: the commerce backend, data model, APIs, extensions, and operational tooling can still become proprietary dependencies. Vendure Commercetools

My shortlist

Current comparisons identify Medusa, Saleor and Vendure as the main open-source headless options, with the important distinction that Medusa uses MIT licensing, Saleor's core uses BSD-3-Clause, while Vendure's core is GPLv3. Vendure Pawel Owerczuk

For a developer, I'd lean toward Medusa

Medusa is a particularly strong fit if you're a TypeScript/JavaScript developer who wants maximum control without having to build commerce completely from scratch. Its core is MIT-licensed, it is self-hostable, and its architecture lets you customize commerce logic rather than merely consuming a vendor's SaaS API. Pawel Owerczuk

That combination matters for portability:

• Source code is available rather than your business logic living exclusively inside a vendor's SaaS.
• Permissive licensing makes maintaining or forking your implementation considerably simpler than with a copyleft core.
• TypeScript/Node lets a JS/TS team use one language across storefront, commerce backend, integrations, and tooling.
• You can run the backend yourself rather than making the vendor's cloud a prerequisite.
• PostgreSQL gives you a conventional database rather than a proprietary data store. Pawel Owerczuk

Saleor is also compelling if your team is comfortable with Python and wants a GraphQL-first architecture. Its open-source project explicitly emphasizes ownership of the stack and avoidance of SaaS lock-in. Saleor Commerce Saleor Commerce

The bigger architectural point

If portability is the actual requirement, I'd make the platform only one part of the strategy.

I'd build something like:

                    Your storefront
                   Next.js / React
                         │
                         ▼
              ┌────────────────────┐
              │  Your commerce API │
              │      Medusa        │
              └────────────────────┘
                 │    │    │    │
          ┌──────┘    │    │    └──────┐
          ▼           ▼    ▼           ▼
       Postgres     Stripe  Search    ERP

And deliberately keep these boundaries under your control:

• Product/catalog data: exportable PostgreSQL/JSON/CSV
• Orders/customers: exportable in your own canonical schema
• Payments: abstract behind your own payment interface
• Search: separate service, rather than commerce-platform-specific search
• CMS: independent of the commerce engine
• Tax/shipping: integration interfaces rather than deeply embedded vendor code
• Images/files: object storage you control
• Frontend: completely independent of the commerce platform
• Business logic: your code/modules, not vendor-specific configuration wherever possible
• Infrastructure: Docker/Kubernetes/standard cloud services rather than proprietary deployment primitives

The goal is that replacing Medusa with Saleor, Vendure, or a custom service becomes an adapter/migration project, rather than rebuilding the entire business.

One important distinction

If your priority were enterprise operational convenience, I'd consider proprietary composable platforms such as commercetools. It is genuinely API-first and modular, but the commerce engine remains a proprietary SaaS service. Commercetools

So I'd frame the decision this way:

Maximum ownership: Medusa / Saleor / Vendure
Maximum TypeScript alignment: Medusa or Vendure
Maximum permissive-license freedom: Medusa or Saleor
Enterprise SaaS/composable convenience: commercetools
Custom frontend while retaining a managed commerce backend: Shopify Hydrogen

For the specific requirement you gave—"I'm an ecommerce developer and I want to maximize long-term portability"—I'd put Medusa and Saleor at the top of the technical evaluation, with the final choice driven primarily by whether you want a TypeScript/REST-oriented or Python/GraphQL-oriented backend. Pawel Owerczuk Eryx Innovations Lab

The most important thing is not choosing the "right" platform forever; it's designing the system so the platform is replaceable.

So I'd frame the decision this way:

If long-term portability and minimizing vendor lock-in are the primary criteria, I’d narrow the field to open-source, self-hostable commerce engines rather than SaaS platforms.

My shortlist

Medusa's architecture, for example, puts API routes, workflows, modules, and PostgreSQL underneath the application, and it can be self-hosted rather than requiring its cloud service. Medusa Docs

What I'd choose for a developer prioritizing portability

Medusa is probably the most straightforward choice if you're a TypeScript/Node developer.

The important distinction isn't merely "headless." It's whether you can take the entire commerce backend with you.

With an open-source/self-hostable system, you can potentially move:

Medusa → your PostgreSQL database → your infrastructure

without having to replace the underlying commerce engine. Medusa's MIT licensing is particularly attractive if you want maximum freedom to fork, modify, or operate the software independently. Current comparisons also put Medusa, Saleor, and Vendure in the strongest category for ownership/self-hosting. ShipGarden Pawel Owerczuk

Saleor is the alternative I'd examine closely if you prefer Python/Django or deliberately want a GraphQL-first architecture. Its core is BSD-3-Clause licensed and it explicitly supports self-hosting. Saleor Commerce

Vendure is another strong TypeScript option, particularly if its plugin architecture and commerce capabilities fit your application, but its GPLv3 licensing makes the legal implications different from Medusa's permissive MIT model. ShipGarden

The bigger issue: don't confuse "headless" with "portable"

You can build a beautifully decoupled Next.js frontend on top of Shopify, BigCommerce, or commercetools and still have substantial backend lock-in. The frontend is portable; your commerce model isn't necessarily.

For maximum portability, I'd design the system around these principles:

• Own the database/data exports.
• Keep your product/catalog/order/customer data in conventional formats you can export.
• Put business-specific logic in your application layer rather than proprietary platform extensions.
• Use standard payment providers rather than platform-specific payment abstractions where practical.
• Keep search, CMS, tax, shipping, email, and analytics replaceable behind interfaces.
• Don't let your frontend directly depend on hundreds of platform-specific API calls.
• Create your own domain interfaces such as ProductRepository, CheckoutService, OrderService, etc.
• Keep the commerce engine behind that boundary so replacing it becomes an implementation change rather than a rewrite.
• Prefer PostgreSQL, REST/GraphQL, webhooks, object storage, and standard infrastructure over proprietary data formats.

That last point is especially important. The architecture you put around the commerce platform can create more lock-in than the platform itself.

My practical decision rule

If I were building a new system today with portability as a first-class requirement:

TypeScript/Node team → Medusa
Python/GraphQL team → Saleor
TypeScript/NestJS team with a strong plugin-oriented architecture → Vendure
Enterprise team that wants managed infrastructure and accepts proprietary SaaS → commercetools
Already deeply invested in Shopify → Shopify headless may be rational, but it isn't the maximum-portability choice.

I wouldn't choose based on feature-count comparisons. I'd prototype catalog → cart → checkout → order → fulfillment → refund → data export, then attempt to recreate the application against a second commerce backend. The platform where that exercise requires the least application-level rewriting is the one that is actually least coupled to your architecture.

Medusa → your PostgreSQL database → your infrastructure

without having to replace the underlying commerce engine. Medusa's MIT licensing is particularly attractive if you want maximum freedom to fork, modify, or operate the software independently. Current comparisons also put Medusa, Saleor, and Vendure in the strongest category for ownership/self-hosting. shipgarden.com owerczuk.dev

Saleor is the alternative I'd examine closely if you prefer Python/Django or deliberately want a GraphQL-first architecture. Its core is BSD-3-Clause licensed and it explicitly supports self-hosting. saleor.io

Vendure is another strong TypeScript option, particularly if its plugin architecture and commerce capabilities fit your application, but its GPLv3 licensing makes the legal implications different from Medusa's permissive MIT model.

The bigger issue: don't confuse "headless" with "portable"