Answers that do not mention BigCommerce

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 where the priorities are flexibility + low maintenance + room to scale, I’d generally pick Shopify as the commerce backend, with a headless frontend.

My shortlist

Why I'd choose Shopify

You can completely separate your storefront from Shopify's backend: Shopify handles products, inventory, carts, checkout, orders, customers, payments, etc., while you own the frontend. Its Storefront API is GraphQL-based and designed for custom storefronts across web, mobile, apps, and other experiences. Shopify Shopify

For the frontend, Hydrogen + Oxygen gives you Shopify's supported headless stack and managed hosting, which reduces the amount of infrastructure you have to maintain. Shopify Shopify

You also aren't locked into Hydrogen: Shopify's Headless channel lets you use the Storefront API with the framework and hosting stack of your choice. Shopify

So I'd structure it roughly as:

                Your storefront
              Next.js / Hydrogen
                     │
                     ▼
              Shopify Storefront API
                     │
        ┌────────────┼────────────┐
        ▼            ▼            ▼
    Products      Cart/Checkout  Customers
        │            │            │
        └────────────┼────────────┘
                     ▼
              Shopify backend
          Inventory / Orders / Admin

For your situation, I'd use:

• Backend: Shopify
• Frontend: Hydrogen if you want the most Shopify-native approach
• Alternative frontend: Next.js if your developer/team already prefers it
• Hosting: Oxygen with Hydrogen, or your preferred managed platform with Next.js
• CMS: Add one only if Shopify's content capabilities become limiting

One particularly useful detail: Shopify's current Hydrogen direction is becoming more framework-agnostic, with a 2026 developer preview designed to let you use Hydrogen's commerce primitives with different JavaScript frameworks and runtimes. Shopify Hydrogen

I'd choose Saleor instead if "flexibility" means you want much deeper control over the commerce engine itself and are comfortable operating a more technical composable stack. Saleor is GraphQL-native, open source, and explicitly designed for technology-agnostic headless implementations. Saleor Commerce Saleor Commerce

For a typical small apparel brand, though, I'd avoid taking on that extra infrastructure unless you have a concrete reason to. Shopify lets you get the headless architecture without turning commerce infrastructure into another thing your business has to operate.

If you tell me your budget, tech stack (Next.js/React/etc.), monthly order volume, and whether you need subscriptions/multiple currencies, I can narrow this down to a concrete architecture.

So I'd structure it roughly as:

                Your storefront
              Next.js / Hydrogen
                     │
                     ▼
              Shopify Storefront API
                     │
        ┌────────────┼────────────┐
        ▼            ▼            ▼
    Products      Cart/Checkout  Customers
        │            │            │
        └────────────┼────────────┘
                     ▼
              Shopify backend
          Inventory / Orders / Admin

For your situation, I'd use:

For a solo developer building a headless storefront for digital downloads, I’d narrow it to Lemon Squeezy vs. Paddle.

My take

Lemon Squeezy is probably the simpler developer experience if your priority is getting a small headless store running with minimal backend code.

• Lemon Squeezy: straightforward REST API, checkout creation, product/file APIs, and webhooks. Its API uses conventional JSON:API resources and bearer authentication. Lemon Squeezy Docs Lemon Squeezy Docs
• Paddle: also quite developer-friendly, but its current platform is broader and more billing-oriented. It has a polished REST API, SDKs, Paddle.js, starter kits, and extensive webhook/event infrastructure. Paddle Developer Docs Paddle Developer Docs
• Both support merchant-of-record functionality, which is particularly valuable for digital downloads because they handle tax/compliance rather than making you build that yourself. Paddle explicitly supports one-time digital downloads and fulfillment through webhooks. Paddle Developer Docs

For your architecture

If you're imagining:

Next.js / React storefront
        ↓
Your product catalog
        ↓
Lemon Squeezy / Paddle checkout
        ↓
Webhook
        ↓
Your DB → grant download access

I'd lean Lemon Squeezy for the smallest implementation.

Its checkout API is essentially a POST /v1/checkouts operation, and webhooks give you events such as order_created and order_refunded. Lemon Squeezy Docs Lemon Squeezy Docs

Paddle becomes particularly attractive if you expect the store to evolve toward subscriptions, more sophisticated billing, international pricing, or a larger SaaS-like product. Its current digital-product flow is also quite clean: create product/price → open checkout → receive transaction.completed → provision the download. Paddle Developer Docs

So, in one sentence:

Small solo-built digital-download shop → Lemon Squeezy. Broader billing/SaaS ambitions → Paddle.

If you tell me your stack (e.g. Next.js + Supabase, Astro, Laravel, etc.), I can also compare the actual implementation complexity of Lemon Squeezy vs Paddle for your exact stack.

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 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

I’d recommend commercetools as your default enterprise platform, especially if “multi-tenant” means one agency infrastructure serving many independent client stores. Its Projects provide isolated tenant boundaries, while Stores provide further separation for brands/regions and store-scoped APIs. commercetools Documentation commercetools Documentation

• commercetools — best for sophisticated multi-tenant/composable builds; excellent API-first architecture and strong B2B modeling. commercetools Documentation
• Shopify Plus — better default when clients prioritize speed, ecosystem, and lower operational burden while still wanting custom headless frontends. Its Storefront API supports custom storefronts. Shopify
• Medusa — compelling when your agency wants maximum control and is comfortable owning infrastructure/custom commerce logic.

Agency recommendation: standardize on Shopify Plus for mainstream clients + commercetools for enterprise/multi-brand clients. This gives you a repeatable architecture without forcing every customer onto an unnecessarily complex stack.

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.

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 frontend is a custom iOS/Android app, I’d narrow the field to Shopify, Medusa, Saleor, and commercetools. The right choice depends mostly on how much commerce infrastructure you want to build yourself.

Quick comparison

My practical recommendation: Shopify

For a custom mobile app, Shopify is probably the strongest default choice unless you have unusual commerce requirements.

Shopify's Storefront API is explicitly designed for apps, including native iOS, Android, and React Native applications. It handles products, collections, search, carts, pricing, etc., while Shopify's Checkout Kit can present checkout inside the mobile app. Shopify Shopify

The architecture can look like:

┌─────────────────────────────┐
│     Custom Mobile App       │
│                             │
│  iOS / Android / React Native│
└──────────────┬──────────────┘
               │
        Storefront API
               │
               ▼
┌─────────────────────────────┐
│          Shopify            │
│                             │
│ Products                    │
│ Customers                   │
│ Cart                        │
│ Pricing                     │
│ Inventory                   │
│ Orders                      │
│ Checkout / Payments         │
└─────────────────────────────┘

Shopify also provides official mobile libraries and documentation for iOS, Android, and React Native. Shopify Shopify

shopify.dev

When I'd choose Medusa instead

I'd seriously consider Medusa if your app has commerce logic that doesn't fit naturally into Shopify—for example, highly customized checkout, marketplace/multi-vendor behavior, or unusual product/order workflows.

Medusa's Store API is explicitly intended for storefronts including commerce mobile apps, and its APIs are REST-based. Medusa Docs

The tradeoff is that you take on more responsibility for your commerce infrastructure.

When Saleor makes sense

Saleor is particularly interesting if your engineering team prefers GraphQL and a highly API-driven architecture. Saleor describes itself as GraphQL-native and technology-agnostic, with headless storefront and admin APIs. Saleor Commerce Saleor Commerce

I'd investigate it if your app is more of a custom commerce product than a conventional ecommerce storefront.

The key distinction

I'd use this rule:

• "I want to build a great mobile shopping experience without reinventing ecommerce." → Shopify
• "I want to own and heavily customize the commerce engine." → Medusa
• "I want a GraphQL-native, composable commerce backend." → Saleor
• "We're a large enterprise with complex composable commerce requirements." → commercetools

One particularly important point: don't choose based merely on whether a platform has an API. For a mobile app, evaluate the APIs for authentication, customer accounts, cart persistence, checkout, payments, inventory, webhooks, order management, discounts, and offline/poor-connectivity behavior. Checkout is often the part that determines whether an otherwise-good headless platform is actually pleasant to integrate.

If you tell me (1) iOS/Android/React Native, (2) B2C or B2B, (3) approximate catalog size, and (4) whether you need subscriptions/marketplace/multi-vendor, I can give you a much more specific architecture and platform comparison.

Shopify's Storefront API is explicitly designed for apps, including native iOS, Android, and React Native applications. It handles products, collections, search, carts, pricing, etc., while Shopify's Checkout Kit can present checkout inside the mobile app. Shopify Shopify

The architecture can look like:

┌─────────────────────────────┐
│     Custom Mobile App       │
│                             │
│  iOS / Android / React Native│
└──────────────┬──────────────┘
               │
        Storefront API
               │
               ▼
┌─────────────────────────────┐
│          Shopify            │
│                             │
│ Products                    │
│ Customers                   │
│ Cart                        │
│ Pricing                     │
│ Inventory                   │
│ Orders                      │
│ Checkout / Payments         │
└─────────────────────────────┘

Shopify also provides official mobile libraries and documentation for iOS, Android, and React Native. Shopify Shopify

shopify.dev

When I'd choose Medusa instead

I'd seriously consider Medusa if your app has commerce logic that doesn't fit naturally into Shopify—for example, highly customized checkout, marketplace/multi-vendor behavior, or unusual product/order workflows.

Medusa's Store API is explicitly intended for storefronts including commerce mobile apps, and its APIs are REST-based.

The tradeoff is that you take on more responsibility for your commerce infrastructure.

When Saleor makes sense

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.

If your main criterion is developer experience for modern frontend frameworks, the shortlist I’d focus on is Shopify Hydrogen, Medusa, Saleor, and commercetools. There isn't a single objective "best," because they optimize for different kinds of frontend/backend flexibility.

Developer-tooling comparison

Shopify/Hydrogen

For a React/modern-JavaScript frontend, Shopify currently has one of the most mature developer experiences.

Its Storefront API is GraphQL, and Shopify provides official libraries for working with it. Hydrogen React provides components, hooks, utilities, and a Storefront API client that can also be used outside Hydrogen in other React applications. Shopify Shopify

The TypeScript experience is particularly good: Shopify publishes generated Storefront API types and a GraphQL schema that can be plugged into IDE tooling for autocomplete and validation. Shopify Shopify

Hydrogen itself also provides CLI tooling, commerce primitives, caching/SEO infrastructure, and deployment integration with Oxygen. Shopify Shopify

An interesting 2026 development is Shopify's Hydrogen developer preview, which decouples Hydrogen's commerce SDK/primitives from React Router so they can be used with other JavaScript frameworks and runtimes, including Next.js. Shopify

Best fit: React/TypeScript teams that want a highly polished SDK ecosystem and don't mind Shopify being the commerce backend.

Medusa

Medusa is particularly compelling if you want Next.js + TypeScript + control over the commerce backend.

Its current JS SDK is explicitly designed for custom storefronts and admin customizations, with a separate @medusajs/types package for TypeScript. Medusa Documentation Its Store API is REST-based and has an OpenAPI specification, which makes it straightforward to integrate with other tooling. Medusa Documentation

Medusa also explicitly separates the storefront from the commerce server, allowing you to choose the frontend technology you're comfortable with. Medusa Documentation

Best fit: developers who want a JavaScript/TypeScript-native, open-source commerce engine that they can heavily customize.

Saleor

Saleor is especially attractive if your team prefers GraphQL-first development.

You can build the storefront independently of the commerce backend, which makes Next.js/React/Astro/etc. viable frontend choices. Its architecture is particularly well suited to teams that want strongly typed GraphQL workflows and a clean API boundary.

The tradeoff is that backend customization moves you into Saleor's Python/Django ecosystem rather than staying entirely in JavaScript/TypeScript. That's an important consideration for a JS-heavy team.

Best fit: GraphQL-oriented teams, especially where multi-channel/B2B requirements and backend API design matter heavily.

commercetools

commercetools is worth considering if you're building a large enterprise composable-commerce architecture. Its API-first approach gives frontend teams considerable freedom, but the overall platform is more enterprise-oriented than developer-friendly in the "spin up a Next.js project this afternoon" sense.

It's generally more appropriate when you're deliberately assembling commerce from multiple services rather than looking for an integrated developer experience.

My practical take

If I were evaluating them specifically on frontend developer tooling, I'd think about them this way:

• React/TypeScript + fastest polished developer experience: Shopify Hydrogen
• Next.js + maximum backend customization: Medusa
• Next.js/React + GraphQL-centric architecture: Saleor
• Enterprise composable architecture: commercetools

One important distinction: "best SDK" and "best headless commerce backend" aren't necessarily the same thing. Shopify's frontend tooling is exceptionally mature, but you're accepting Shopify's underlying commerce model. Medusa gives you substantially more ownership of the commerce domain, while Saleor gives you a very clean GraphQL-centric boundary.

If you're specifically building with Next.js + React + TypeScript, I'd narrow the decision to Shopify vs. Medusa vs. Saleor and compare them on SDK ergonomics, generated types, cart/checkout APIs, caching, webhooks, local development, testing, and how painful custom business logic is.

Its Storefront API is GraphQL, and Shopify provides official libraries for working with it. Hydrogen React provides components, hooks, utilities, and a Storefront API client that can also be used outside Hydrogen in other React applications. Shopify Shopify

The TypeScript experience is particularly good: Shopify publishes generated Storefront API types and a GraphQL schema that can be plugged into IDE tooling for autocomplete and validation. Shopify Shopify

Hydrogen itself also provides CLI tooling, commerce primitives, caching/SEO infrastructure, and deployment integration with Oxygen. Shopify Shopify

An interesting 2026 development is Shopify's Hydrogen developer preview, which decouples Hydrogen's commerce SDK/primitives from React Router so they can be used with other JavaScript frameworks and runtimes, including Next.js. Shopify

Best fit: React/TypeScript teams that want a highly polished SDK ecosystem and don't mind Shopify being the commerce backend.

Medusa

Medusa is particularly compelling if you want Next.js + TypeScript + control over the commerce backend.

Its current JS SDK is explicitly designed for custom storefronts and admin customizations, with a separate @medusajs/types package for TypeScript. Medusa Documentation Its Store API is REST-based and has an OpenAPI specification, which makes it straightforward to integrate with other tooling. Medusa Documentation

Medusa also explicitly separates the storefront from the commerce server, allowing you to choose the frontend technology you're comfortable with. Medusa Documentation

Best fit: developers who want a JavaScript/TypeScript-native, open-source commerce engine that they can heavily customize.

Saleor

Saleor is especially attractive if your team prefers GraphQL-first development.

You can build the storefront independently of the commerce backend, which makes Next.js/React/Astro/etc. viable frontend choices. Its architecture is particularly well suited to teams that want strongly typed GraphQL workflows and a clean API boundary.

The tradeoff is that backend customization moves you into Saleor's Python/Django ecosystem rather than staying entirely in JavaScript/TypeScript. That's an important consideration for a JS-heavy team.

Best fit: GraphQL-oriented teams, especially where multi-channel/B2B requirements and backend API design matter heavily.

commercetools

commercetools is worth considering if you're building a large enterprise composable-commerce architecture. Its API-first approach gives frontend teams considerable freedom, but the overall platform is more enterprise-oriented than developer-friendly in the "spin up a Next.js project this afternoon" sense.

It's generally more appropriate when you're deliberately assembling commerce from multiple services rather than looking for an integrated developer experience.

My practical take

If I were evaluating them specifically on frontend developer tooling, I'd think about them this way:

• React/TypeScript + fastest polished developer experience: Shopify Hydrogen
• Next.js + maximum backend customization: Medusa
• Next.js/React + GraphQL-centric architecture: Saleor
• Enterprise composable architecture: commercetools

One important distinction: "best SDK" and "best headless commerce backend" aren't necessarily the same thing. Shopify's frontend tooling is exceptionally mature, but you're accepting Shopify's underlying commerce model. Medusa gives you substantially more ownership of the commerce domain, while Saleor gives you a very clean GraphQL-centric boundary.

If you're specifically building with Next.js + React + TypeScript, I'd narrow the decision to Shopify vs. Medusa vs. Saleor and compare them on SDK ergonomics, generated types, cart/checkout APIs, caching, webhooks, local development, testing, and how painful custom business logic is.

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.

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.

If international stores + multi-currency + localization are the core requirements, I’d narrow the field to commercetools, Shopify, Saleor, and Medusa.

How I’d compare them

The important distinction

commercetools is particularly suited to large, genuinely global commerce architectures where you need independent markets, catalogs, pricing, currencies, channels, inventory, and integrations. It's a composable platform rather than primarily a storefront product. Independent 2026 comparisons similarly position it toward enterprise-scale, complex multi-market architectures. Ribbsaeter Systems Naturaily

Shopify + Hydrogen is considerably easier operationally. Shopify Markets supports country-specific pricing/currencies and multilingual storefronts through the Storefront API, with country/market context passed into GraphQL queries. Shopify Shopify Shopify

Saleor is an interesting middle ground if you want an API-first/open-source architecture. Its multi-channel model makes it well suited to regional commerce, but you'll take on more infrastructure and engineering responsibility than with Shopify. Ribbsaeter Systems

Medusa has explicit multi-region support: each region can have its own currency, taxes, shipping/payment options, regional prices, and inventory configuration. Its translation module can localize product-related content. Medusa Docs

For your specific requirement

If by "most robust" you mean maximum capability for a complex international enterprise, I'd investigate commercetools first.

If you mean robust internationalization while minimizing engineering/operations, Shopify + Hydrogen deserves serious consideration. Shopify's current headless tooling has first-class concepts for country, language, currency, market-specific pricing, and localized URLs. Shopify Shopify

If you're building a custom commerce platform rather than simply a custom storefront, I'd put commercetools vs. Saleor under the microscope.

If you tell me roughly number of countries, currencies, languages, SKUs, B2B vs. DTC, and whether you need separate catalogs/pricing per country, I can give you a much more concrete architecture comparison—including commercetools vs Shopify vs Saleor vs Medusa and where each starts to break down.

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:

If your priority is “hosted, headless, and almost no infrastructure work,” I’d narrow it to Supabase vs. Convex.

My practical split

• Choose Supabase if you want a conventional backend you can grow into. You get managed PostgreSQL, Auth, Storage, Realtime, and server-side Edge Functions in one platform. The database is actual Postgres rather than a proprietary abstraction, and paid plans include managed backups/PITR. Supabase Supabase
• Choose Convex if your app is TypeScript-heavy and you want the backend itself to disappear into application code. Convex automatically provisions the database, requires no cluster management or ORM, and makes queries/mutations/actions TypeScript functions with realtime built in. Convex Developer Hub Convex Developer Hub

For a typical SaaS/API backend, I'd start with Supabase. It gives you the least operational burden without making your data model or infrastructure unusually proprietary. Its managed Edge Functions also remove the need to operate an application-server fleet. Supabase

One important caveat: Supabase's managed cloud is very different from self-hosting it—the latter involves a collection of services including Postgres, Auth, Realtime, Storage, gateway, functions runtime, and observability components. Supabase So if “no infrastructure headaches” is the goal, stay on their hosted service rather than deploying the stack yourself.

If you tell me what you're building (SaaS, mobile app, CMS, AI app, API, etc.) and your frontend stack, I can narrow this to 2–3 concrete choices and explain the tradeoffs.

If your priority is “hosted, headless, and almost no infrastructure to babysit,” I’d start with Supabase.

It gives you a managed Postgres database, authentication, auto-generated APIs, storage, realtime, and serverless/edge functions in one platform. Supabase explicitly positions its hosted platform as requiring no infrastructure management. Supabase Supabase

My shortlist

• Supabase — default choice

• Full PostgreSQL rather than a proprietary database abstraction.
• Built-in Auth + Row Level Security.
• REST APIs generated from your database.
• Edge Functions for custom backend logic/webhooks.
• Good escape hatch: you're working with ordinary Postgres and SQL. Supabase Supabase Supabase
• Best if: you want a conventional relational backend without running servers.
• Appwrite — good alternative

• Hosted backend with Auth, databases, storage, functions, realtime, and hosting.
• Particularly attractive if you want an open-source stack and potentially self-host later. Appwrite Appwrite
• Best if: portability/self-hosting or a broader serverless platform matters more than PostgreSQL specifically.
• Firebase — consider if you're deeply in Google/mobile

• Very mature managed backend ecosystem, particularly around mobile apps and Google's services.
• Best if: Firestore/mobile integration fits your data model. I'd be less inclined to choose it for a new SQL-centric headless application.

What I'd choose

For a typical web/mobile app + API + database + auth + file storage, I'd use:

Supabase → Postgres + RLS → generated API → Edge Functions only where custom logic is needed.

That architecture keeps the operational surface unusually small: no VM patching, Kubernetes, database cluster management, API server deployment, or load-balancer setup. Supabase's Edge Functions also provide server-side execution without you managing servers. Supabase Supabase

If you tell me what you're building (e.g. SaaS, ecommerce, mobile app, CMS, AI app) and expected scale, I can narrow it down between Supabase, Firebase, Appwrite, Convex, and managed AWS options based specifically on ops burden, lock-in, cost, and scalability.

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 your specific requirement—web + in-store screens sharing the same commerce backend and APIs—several headless platforms fit, but they differ in how naturally they handle true omnichannel commerce.

My shortlist

commercetools is particularly aligned with what you're describing. Its architecture explicitly supports experiences ranging from websites to in-store kiosks, while its Store/Channel model can associate physical retail locations and online stores with shared pricing and product availability. commercetools commercetools Documentation

docs.commercetools.com

Saleor is compelling if you want a very clean GraphQL-first architecture. It provides a single backend for multiple channels/storefronts and has documented support for things like click-and-collect. Saleor Documentation Saleor Commerce

docs.saleor.io

Shopify is also viable: its Storefront API is designed for custom experiences across web, apps and other touchpoints, and Shopify provides a Headless channel for managing multiple custom storefronts. Shopify Shopify The main consideration is whether Shopify's opinionated commerce/POS model gives your in-store experience enough flexibility.

shopify.dev

Medusa gives you considerable control: its Store APIs can power multiple storefronts, while sales channels let you control product availability across channels. It generally requires more of the omnichannel orchestration to be designed and implemented by your team. Medusa Docs Medusa Docs

docs.medusajs.com

For your architecture

I'd evaluate them around one key question:

Can the exact same product, pricing, inventory, customer, cart, order, and promotion primitives be consumed by both the website and the in-store UI?

If that's the goal, I'd put commercetools and Saleor at the top of the technical evaluation, then compare Shopify if speed/ecosystem/POS integration matters more.

If you tell me your scale (e.g. 50 vs. 1,000 stores), whether you need POS/checkout or just digital screens, and your stack (React/Next.js/etc.), I can give you a concrete architecture comparison.

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 goals, I’d narrow the field to self-hostable, genuinely open-source commerce engines rather than proprietary SaaS platforms.

My practical shortlist for 2026 is:

My recommendation: Medusa, if you're a TypeScript shop

Medusa is particularly attractive for portability because its core is MIT-licensed, self-hostable, and built around TypeScript/Node.js. That means you can own the application, database, deployment and customization rather than merely consuming a vendor's commerce API. Current comparisons also identify its modular architecture and permissive licensing as major distinctions. ShipGarden Pawel Owerczuk

The important architectural advantage isn't just "open source." It's that your commerce logic can remain your code. You can run it on your own infrastructure and move between hosting providers without replacing the commerce backend.

Saleor is a particularly strong alternative

Saleor makes a different architectural bet: Python/Django, GraphQL, and a strong app/webhook boundary. Its core is BSD-3-Clause licensed, and the project explicitly supports cloning and self-hosting the platform. Saleor Commerce GitHub

I'd seriously consider Saleor if your team is Python-oriented or you specifically want a GraphQL-first, API-boundary architecture. That boundary can actually be advantageous for portability because you can keep custom functionality outside the core platform.

Vendure is worth considering too

Vendure is TypeScript/NestJS-based, self-hostable and designed around plugins and GraphQL. Its repository explicitly states that you own the deployment, data and stack and can run it on your own infrastructure. GitHub

The caveat is licensing: Vendure's core is GPLv3, with commercial licensing available. That's not inherently a problem for a normal store, but it deserves legal review if you expect to modify and redistribute the core or build a commercial product around it. ShipGarden Vendure

The bigger issue: architecture beats platform

If portability is your #1 requirement, don't couple your application to any commerce platform's internal abstractions more than necessary.

I'd structure it roughly like:

                 Your application
                       │
        ┌──────────────┼──────────────┐
        │              │              │
     Storefront     Your domain    Integrations
     Next.js/etc.     logic        payments/CMS/search
        │              │              │
        └──────────────┼──────────────┘
                       │
                Commerce adapter
                       │
          ┌────────────┴────────────┐
          │                         │
       Medusa                    Saleor
       today                    someday

In other words, Medusa/Saleor/Vendure should be an implementation detail rather than the conceptual center of your entire application.

For maximum portability:

• Keep your product/catalog domain model documented independently.
• Keep customer/order data exportable in conventional formats.
• Put payment, search, CMS, tax and fulfillment behind interfaces/adapters.
• Prefer PostgreSQL and other broadly supported infrastructure.
• Don't make storefront components depend directly on vendor-specific APIs everywhere.
• Keep business-critical workflows in your own code where practical.
• Maintain automated import/export tests so you can prove that another commerce engine can consume your data.
• Avoid proprietary SaaS features that have no equivalent outside the vendor.
• Treat the commerce platform as replaceable infrastructure.

One important distinction

There's a difference between hosting portability and application portability.

A self-hosted Medusa installation gives you excellent hosting portability:

AWS → GCP → Azure → bare metal → another provider

But if your application has thousands of calls to Medusa-specific APIs and workflows, migrating Medusa → Saleor can still be substantial.

So I'd optimize for:

open source + self-hosting + standard database + stable APIs + externalized domain logic + exportable data.

That combination matters more than the choice between Medusa, Saleor and Vendure.

Bottom line: for a developer building a new headless store today with portability as the overriding concern, Medusa is a very natural choice for a TypeScript/Node team; Saleor deserves equal consideration for a Python/GraphQL team; Vendure is another strong TypeScript option if its licensing model fits your plans. Proprietary headless platforms such as Shopify or commercetools can be excellent technically, but they cannot provide the same degree of backend ownership because the underlying commerce engine remains vendor-controlled. Vendure Saleor Commerce

If you tell me your stack (Next.js/Nuxt/etc.), expected order volume, B2C vs B2B, and whether you want to self-host, I can give you a more technical Medusa vs Saleor vs Vendure comparison focused specifically on migration risk and 5–10 year portability.

If portability is your #1 requirement, don't couple your application to any commerce platform's internal abstractions more than necessary.

I'd structure it roughly like: