Answers that name a competitor

For a small clothing brand, I’d optimize for low operational burden first, flexibility second. A lot of brands overbuild headless systems and end up maintaining infrastructure instead of selling clothes.

My shortlist:

PowerGate Software Naturaily## My recommendation: start with Shopify headless

For a small apparel brand, I’d usually pick:

Shopify backend + custom frontend (Next.js/Hydrogen) + a CMS for storytelling content

Why:

• You get inventory, orders, payments, taxes, discounts, returns, and fulfillment handled for you.
• Your team can manage products without engineering help.
• You can still build a premium storefront with custom UX.
• You avoid spending time maintaining databases, queues, deployments, security patches, and scaling issues.

Shopify’s biggest advantage is operational simplicity; its weakness is that you are working within Shopify’s commerce model rather than owning every backend detail. Hunchbite

A typical stack:

• Frontend: Next.js or Shopify Hydrogen
• Commerce: Shopify Storefront API
• Content: Sanity, Contentful, or another headless CMS
• Search: Algolia/Typesense (if your catalog grows)
• Hosting: Vercel/Cloudflare

When I would choose Medusa instead

Pick Medusa if you know you need things like:

• unusual checkout flows
• custom product configuration
• marketplace features
• unique pricing rules
• full ownership of the backend
• a team comfortable running infrastructure

Medusa is attractive because it is open-source and TypeScript-based, which fits well with modern JavaScript storefronts. The tradeoff is that you own more of the operational responsibility. Hunchbite OSSAlt

I would avoid (for now)

I would probably not start with Saleor or commercetools unless you already have engineering resources and a clear reason.

They are powerful, but a small clothing company usually benefits more from shipping collections, campaigns, and customer experiences than from building a highly customized commerce engine. Naturaily Vendure

A practical decision rule

Choose:

• Shopify headless → under ~$5–10M/year revenue, small team, want reliability
• Medusa → strong developers, custom business model, willing to operate software
• Saleor/commercetools → complex B2B, multiple markets, enterprise workflows

If I were launching a clothing brand today and wanted flexibility without creating a technical burden, I’d build a custom frontend on Shopify first. Migrate to a more custom backend only when Shopify becomes the constraint, not before.

They are powerful, but a small clothing company usually benefits more from shipping collections, campaigns, and customer experiences than from building a highly customized commerce engine.

A practical decision rule

Choose:

For a mid-size retailer on a tight timeline, I’d shortlist Shopify Hydrogen and BigCommerce Catalyst—with Shopify Hydrogen usually the safest fast-implementation choice.

• Shopify + Hydrogen/Oxygen: Best if you prioritize speed, ecosystem, checkout, and minimizing infrastructure work. Shopify provides an opinionated headless stack, CLI, prebuilt commerce tooling, and managed Oxygen hosting. Shopify Shopify
• BigCommerce + Catalyst: Strong alternative if you need more backend/catalog flexibility or B2B capabilities. Catalyst gives you a production-ready Next.js/React storefront rather than starting from scratch. BigCommerce BigCommerce
• commercetools: I'd avoid for a deadline-driven mid-market migration unless you already have substantial composable-commerce engineering expertise; it's better suited to complex enterprise architectures.

My pick: Shopify Hydrogen if you're already on Shopify; BigCommerce Catalyst if you're selecting the commerce backend too.

For a mid-size retailer with a tight implementation window, I’d shortlist these:

1. shopify.com — my default choice for speed

• Best if you want headless UX without taking on a huge amount of backend engineering.
• Hydrogen is Shopify’s purpose-built headless stack, with prebuilt commerce components, APIs, CLI tooling, and deployment through Oxygen. Shopify Hydrogen
• You can also migrate incrementally; Shopify supports shared carts between the existing storefront and Hydrogen. Shopify
• Typical fit: DTC retailer, conventional catalog/checkout, moderate integrations, small-to-medium engineering team.
• bigcommerce.com — strong alternative

• Particularly attractive if you want a more open backend and don't want to be as tightly coupled to Shopify's ecosystem.
• I'd consider it when you have meaningful B2B, complex catalog requirements, or existing integrations that make Shopify less straightforward.
• commercetools.com — powerful, but not my first pick for a rushed mid-market rollout

• Excellent if your real objective is a highly composable architecture with complicated pricing, markets, B2B, inventory, or multiple commerce channels.
• It is substantially more of an engineering/platform project. commercetools itself positions its platform around modular, API-first commerce. commercetools commercetools
• Its newer standalone modules can also let enterprises modernize individual capabilities without a full replatform, which is interesting for phased migrations. commercetools

What I'd choose

If "go live quickly" is genuinely the #1 constraint, I'd go:

Shopify Plus backend → Hydrogen storefront → Oxygen hosting → existing CMS/search/PIM integrations where needed.

That's a relatively opinionated path, which is exactly what you want when the schedule is tight. Shopify's current tooling lets you create, connect, and deploy a Hydrogen storefront through the CLI, rather than assembling the entire headless infrastructure yourself. Shopify

I'd avoid building a fully bespoke composable stack just because "headless" sounds like maximum flexibility. Every additional independently managed service is another integration, deployment, monitoring, and failure point.

If you tell me your current platform (Magento, Salesforce Commerce Cloud, Shopify, custom, etc.), approximate revenue/order volume, frontend framework, and deadline, I can narrow this to a specific stack and give you a 30/60/90-day implementation plan.

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, the best balance of cost, speed, and features is usually:

🥇 Best overall value: Medusa (open-source headless commerce)

Best fit: A technical startup building a custom storefront (Next.js/React, mobile app, marketplace, subscriptions, unusual checkout flows).

Why it balances cost and features well:

• ✅ Open-source core → no expensive platform license
• ✅ TypeScript/Node.js ecosystem → easier hiring for many modern web teams
• ✅ Strong customization (products, carts, payments, fulfillment, promotions)
• ✅ Can start self-hosted cheaply and move to managed hosting later
• ✅ Avoids the large enterprise pricing jumps seen in some platforms Hunchbite ShipGarden

Trade-offs:

• ❌ You own more infrastructure (database, deployments, upgrades)
• ❌ Smaller plugin/app ecosystem than Shopify
• ❌ Requires engineering capability Ribbsaeter Systems

Startup recommendation: If you have 1–3 solid developers, Medusa is probably the strongest cost-to-control ratio.

🥈 Best if you want to launch fast: Shopify + headless storefront

Best fit: A brand selling straightforward products that wants revenue quickly.

Advantages:

• ✅ Extremely mature checkout, payments, inventory, tax, fraud tools
• ✅ Huge app ecosystem
• ✅ Less DevOps work
• ✅ Easier for non-technical teams to operate Ribbsaeter Systems

Downsides:

• ❌ Less control over backend logic
• ❌ Costs can rise as you scale
• ❌ Some advanced headless capabilities push you toward higher-tier plans Hunchbite

Startup recommendation: Pick Shopify if your biggest risk is "can we get customers?" rather than "can we build a differentiated commerce engine?"

🥉 Best for complex B2B: Saleor

Best fit: Wholesale, multi-channel, complex catalogs, international commerce.

Strengths:

• ✅ Strong GraphQL-first architecture
• ✅ Good multi-channel and B2B capabilities
• ✅ Open-source option Softwr

Weaknesses:

• ❌ More expensive operationally if using managed hosting
• ❌ Smaller ecosystem
• ❌ Better suited to teams with Python/Django experience OSSAlt

Quick startup comparison

Ribbsaeter Systems## My default recommendation by startup stage

• Pre-revenue / MVP: Shopify (fastest validation) or Medusa (if engineering is your advantage)
• $0–$1M revenue, technical team: Medusa
• $1M–$10M revenue, custom experience needed: Medusa or Shopify headless
• Complex B2B workflows: Saleor

For most funding-constrained startups building something differentiated, I would lean toward Medusa + Next.js + Stripe + a headless CMS. It keeps monthly costs low while avoiding a painful platform migration later. ShipGarden OSSAlt

The main exception: if you have no engineering resources, Shopify is usually the better investment because developer time will cost more than platform fees.

For an enterprise catalog with thousands of SKUs and genuinely complex product models, I’d put commercetools at the top of the shortlist.

My shortlist

Why I'd lean commercetools

Its catalog model is unusually suited to complicated enterprise SKUs. You can define Product Types with custom attributes, distinguish product-level from variant-level attributes, make attributes searchable/filterable, and use custom fields for additional domain data. commercetools Documentation commercetools Documentation commercetools Documentation

More importantly for a large catalog, commercetools introduced a Modular Product Catalog in 2026 where variants become first-class resources. That allows a product to have up to 10,000 variants, rather than the 100-variant limit of its classic embedded model. commercetools Documentation commercetools Documentation

Its architecture is also genuinely API-first: commerce capabilities are exposed through independent APIs rather than treating headless as merely a storefront option. commercetools

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

Product → configurable attributes → thousands of SKU combinations → regional assortments → customer-specific pricing → inventory/ERP → multiple storefronts/apps/marketplaces

When I'd choose something else

• BigCommerce — I'd choose this if you want headless APIs but want a somewhat more packaged commerce backend. It provides both GraphQL Storefront and REST product APIs. BigCommerce BigCommerce
• Saleor — compelling if your engineering organization wants an API-centric, GraphQL-heavy platform and is comfortable owning more of the architecture.
• Medusa — interesting for a JavaScript/TypeScript-heavy engineering team that wants to customize the commerce domain substantially; its product module supports custom options, variants, bundles/multi-part products, and tiered pricing. Medusa Docs
• Shopify Plus — excellent operationally, but I'd be more cautious if your catalog model itself is the difficult part rather than checkout, merchandising, and ecosystem integration.

Bottom line: if the defining requirement is "thousands of SKUs + complex relationships/attributes + multiple channels + deep API integration", I'd start the evaluation with commercetools, then compare it against BigCommerce and Saleor based on how much customization your engineering team wants to own.

If you tell me roughly how your product model works (variants, bundles/kits, configurable products, regional catalogs, B2B pricing, compatibility relationships, etc.), I can narrow this to 2–3 platforms and show how each would model your catalog.

More importantly for a large catalog, commercetools introduced a Modular Product Catalog in 2026 where variants become first-class resources. That allows a product to have up to 10,000 variants, rather than the 100-variant limit of its classic embedded model. commercetools Documentation commercetools Documentation

Its architecture is also genuinely API-first: commerce capabilities are exposed through independent APIs rather than treating headless as merely a storefront option.

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

Product → configurable attributes → thousands of SKU combinations → regional assortments → customer-specific pricing → inventory/ERP → multiple storefronts/apps/marketplaces

When I'd choose something else

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

My ranking

1. commercetools — my pick for your requirement

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

More importantly, its current Checkout product supports two modes:

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

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

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

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

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

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

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

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

I'd choose Saleor over commercetools if:

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

The tradeoff is that you own more of the complexity.

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

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

So you can do:

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

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

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

But it's less ideal if you mean:

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

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

What I'd do

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

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

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

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

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

docs.commercetools.com
docs.commercetools.com

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

If the frontend is a custom mobile app—React Native, Flutter, Swift/Kotlin, etc.—I’d prioritize a commerce platform with a strong, stable API rather than one optimized around a particular web storefront.

My shortlist

🥇 I'd choose Medusa for a custom mobile app

Medusa is particularly attractive when the mobile app is the primary customer experience.

Your architecture can look roughly like:

React Native / Flutter / iOS / Android
                │
                ▼
        Your API / BFF layer
                │
                ▼
            Medusa
       ┌────────┼────────┐
       ▼        ▼        ▼
    Products   Cart    Orders
       │        │        │
       └────────┼────────┘
                ▼
     Payments / Tax / Shipping

The big advantage is that your app isn't tied to a commerce-specific frontend framework. Medusa is a backend commerce engine, so you can build the mobile UX however you want. Its TypeScript/Node architecture is also convenient if your app/backend team already lives in the JavaScript/TypeScript ecosystem. Eryx Innovations Lab OSSAlt

When I'd pick Saleor instead

Choose Saleor if your app needs things like:

• Complex B2B pricing
• Multiple markets/channels
• Multiple warehouses
• Sophisticated product attributes
• GraphQL as the primary API
• A Python/Django backend team

Saleor is particularly strong if you want the mobile app to consume a GraphQL-first commerce API. Vendure OSSAlt

When Shopify makes more sense

I'd pick Shopify if you care more about getting the business operational quickly than owning the commerce backend.

You can absolutely have:

Custom Mobile App
       │
       ▼
Shopify Storefront API
       │
       ▼
Shopify
       │
 ┌─────┼─────┐
 ▼     ▼     ▼
Pay  Orders Inventory

The tradeoff is that you're working within Shopify's commerce model rather than having complete control over the backend. That's often a very good trade for a smaller team because Shopify takes care of a lot of operational complexity. Current 2026 comparisons generally position Shopify as the fastest/lowest-operational-burden choice, while Medusa and Saleor provide considerably more backend ownership. Ribbsaeter Systems Naturaily

My recommendation by situation

• Startup / new product / highly customized app → Medusa
• B2B / complex pricing / multi-region → Saleor
• Large enterprise / composable architecture → commercetools
• Want to launch quickly and minimize backend operations → Shopify
• Mid-market + managed SaaS + API access → BigCommerce

One important architectural recommendation: even with Medusa/Saleor/etc., I'd consider putting a thin BFF (Backend-for-Frontend) between your mobile app and commerce platform. It lets you combine commerce, CMS, search, personalization, loyalty, analytics, etc. into mobile-optimized responses and prevents your app from becoming tightly coupled to the commerce vendor.

If you tell me React Native vs Flutter vs native, expected number of SKUs/orders, B2C vs B2B, and whether you need subscriptions/marketplace/multiple countries, I can narrow this down to the best 1–2 choices and give you a concrete architecture.

The big advantage is that your app isn't tied to a commerce-specific frontend framework. Medusa is a backend commerce engine, so you can build the mobile UX however you want. Its TypeScript/Node architecture is also convenient if your app/backend team already lives in the JavaScript/TypeScript ecosystem.

When I'd pick Saleor instead

If your priority is CMS-first, with commerce exposed through APIs rather than letting the commerce platform dictate the page experience, I’d choose based on how much commerce complexity you need.

My default recommendation: Shopify + a real headless CMS

Use Shopify as the commerce engine and a CMS such as Contentful, Sanity, or Storyblok as the content layer.

Architecture:

CMS
 ├─ Product-page composition
 ├─ Editorial content
 ├─ SEO
 ├─ Landing pages
 └─ Merchandising/content blocks
          │
          ▼
   Next.js / React
          │
     ┌────┴────┐
     ▼         ▼
   CMS API   Shopify
             Storefront API
             ├─ products
             ├─ variants
             ├─ pricing
             ├─ inventory
             ├─ cart
             └─ checkout

Shopify's Storefront API is specifically designed to expose products, collections, carts, search, pricing, etc. to a custom frontend, and it is framework-agnostic—you can use Next.js, Vue, or your own stack. Shopify Shopify

For the frontend, Next.js + Shopify Storefront API + your CMS is probably the most pragmatic choice.

When I'd choose something else

commercetools is particularly compelling if your phrase "CMS-first" really means commerce should be one interchangeable service among many. It is explicitly built around modular APIs and composable commerce. commercetools

Medusa is another strong option if you want the commerce layer to be more developer-controlled; its Store API is REST-based and intended specifically to power custom storefronts. Medusa Docs

One important distinction

I would not make the commerce platform your CMS.

Instead, make the CMS own the product-page experience, while the commerce API owns transactional truth.

For example:

CMS owns:
- Page layout
- Hero
- Product storytelling
- Rich media
- Buying-guide sections
- FAQs
- SEO metadata
- Related editorial content
- Promotional modules

Commerce owns:
- Product ID
- Variants
- Price
- Availability
- Inventory
- Cart
- Discounts
- Checkout
- Orders

Then your product page becomes something like:

CMS:
  "page": {
    "product": "shopify:gid://product/123",
    "blocks": [
      "hero",
      "product_buy_box",
      "story",
      "ingredients",
      "reviews",
      "related_content"
    ]
  }

Commerce API:
  product(123) {
    title
    variants
    price
    availability
    images
  }

That gives your content team control over the page, without duplicating commerce data in the CMS.

If I were starting today

I'd probably go:

Sanity or Contentful → Next.js → Shopify Storefront API → Shopify checkout

and only move to commercetools if you have genuine enterprise/composable requirements that Shopify starts constraining.

Shopify also has Hydrogen if you want its more integrated headless stack; Shopify currently describes Hydrogen/Oxygen as its recommended headless commerce stack. Shopify Shopify

If you tell me B2C vs B2B, approximate SKU count, number of locales, and whether editors need to visually compose product pages, I can narrow this down to 2–3 architectures and explain the tradeoffs.

If your team strongly prefers serverless frontends + Jamstack, I’d shortlist these:

My default recommendation: Shopify

For a Jamstack/serverless team, Shopify's Storefront API is probably the lowest-risk choice. It lets you keep the frontend completely separate and build with Next.js, Astro, Vue, or essentially any framework. Shopify explicitly supports framework-agnostic Storefront API usage. Shopify Shopify

A typical architecture would be:

             ┌─────────────────────┐
             │  CDN / Edge         │
             │  Next.js / Astro    │
             │  Vercel / Netlify   │
             └──────────┬──────────┘
                        │
                 Storefront API
                        │
             ┌──────────▼──────────┐
             │      Shopify        │
             │ Products / Cart     │
             │ Checkout / Orders   │
             └─────────────────────┘

If you're React-oriented, Hydrogen is Shopify's purpose-built headless framework, with server-side/edge rendering and deployment through Oxygen. Shopify Hydrogen

An especially interesting development in 2026 is Shopify's Hydrogen developer preview, which makes the commerce layer framework- and runtime-agnostic. Shopify says it can work with Next.js, SvelteKit, Astro, Nuxt, Cloudflare Workers, Vercel, Oxygen, and others. It's still a developer preview, though, so I wouldn't make it the basis of a production architecture yet without evaluating its maturity. Shopify Hydrogen

When I'd choose Saleor instead

If your team is engineering-heavy and wants commerce to feel like an API-native backend rather than a SaaS storefront, Saleor is very compelling. Its platform is GraphQL-native, headless across both storefront and admin, and designed to work with essentially any frontend/BFF stack. Saleor

I'd favor it when you want:

• React/Next.js/Astro/etc. on the frontend
• GraphQL throughout the stack
• open-source/self-hosted control
• highly customized commerce flows
• less dependence on a traditional ecommerce SaaS model

When I'd choose commercetools

For enterprise composable commerce, I'd put commercetools at the top of the list. It's API-first and explicitly designed to separate the experience layer from commerce capabilities, with individual commerce capabilities composable independently. commercetools

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

The decision I'd make

Small/mid-sized team → Shopify Storefront API
Engineering-led/open-source team → Saleor
Large enterprise with complex B2B/composable requirements → commercetools
Node.js team wanting to own the commerce backend → Medusa

If you tell me your frontend stack (Next.js, Astro, Gatsby, Nuxt, etc.), approximate SKU count, B2C vs B2B, and whether you need subscriptions/multi-region/multi-brand, I can narrow this to the best 2–3 options and compare their architecture, pricing, and serverless deployment model.

If your team is engineering-heavy and wants commerce to feel like an API-native backend rather than a SaaS storefront, Saleor is very compelling. Its platform is GraphQL-native, headless across both storefront and admin, and designed to work with essentially any frontend/BFF stack.

I'd favor it when you want:

If your main criterion is developer experience + SDK quality for modern frontend frameworks, my pick is Shopify, with Medusa as the strongest alternative if you want more backend control.

My ranking

🥇 Best overall: Shopify

Shopify has probably the strongest combination of mature APIs, SDKs, TypeScript support, documentation, examples, tooling, and frontend ecosystem.

Its Storefront API is GraphQL-based and explicitly designed to work across web, apps, and other clients. Shopify officially provides a Storefront API client, Hydrogen, React Router tooling, and Hydrogen React. Shopify Shopify

The particularly interesting development in 2026 is that Shopify is moving Hydrogen toward a framework-agnostic toolkit. The developer preview lets you use Hydrogen's commerce primitives with essentially any JavaScript framework/runtime, including Next.js. Shopify Hydrogen

That makes Shopify unusually attractive if your frontend team wants to use:

• Next.js
• React Router
• Hydrogen
• Astro
• other JavaScript frameworks
• TypeScript
• custom server/client architectures

Shopify also has generated TypeScript types for its Storefront API, which is a significant DX advantage for strongly typed frontends. Shopify

Verdict: If you want your developers to spend their time building the frontend rather than maintaining commerce infrastructure, Shopify is the safest choice.

shopify.dev

🥈 Best for developer control: Medusa

Medusa is arguably more interesting than Shopify if you're building something that doesn't fit conventional ecommerce.

Medusa has a dedicated JS SDK (@medusajs/js-sdk) and TypeScript types, and its documentation explicitly supports custom storefronts. Its SDK covers things such as products, customers, authentication, pricing, orders, regions, and sales channels. Medusa Docs Medusa Docs Medusa Docs Medusa Docs

It also has explicit Next.js integration, including support for Next.js caching/revalidation semantics. Medusa Docs

The big difference is architectural:

Shopify:

Your application → Shopify APIs → Shopify commerce engine

Medusa:

Your frontend → Medusa → your customizable commerce backend

That makes Medusa much more compelling for marketplaces, unusual checkout flows, custom pricing logic, multi-vendor systems, or products that require substantial domain-specific commerce logic.

Medusa's current developer tooling also includes CLI tooling, JS SDK, Next.js starter, MCP/agent tooling, and integrations. Medusa Docs

docs.medusajs.com

🥉 Best API architecture: Saleor

Saleor is worth serious consideration if your team is GraphQL/TypeScript-heavy.

Its appeal is less "huge ecosystem" and more clean, API-first architecture. I'd put it ahead of Medusa if your team strongly prefers GraphQL and wants commerce to behave like a composable backend service.

Enterprise: commercetools

commercetools is arguably the strongest choice when you're talking about large enterprise engineering organizations rather than a startup/product team.

Its APIs and SDK approach are excellent, but the overall developer experience isn't quite as immediately approachable as Shopify or Medusa. You're trading some simplicity for deep composability and enterprise capabilities.

The important distinction

I'd actually divide the market into three categories:

Want the best frontend developer experience? → Shopify

Want the most control over the commerce backend? → Medusa

Want enterprise-grade composable commerce? → commercetools

And if your stack is specifically Next.js + TypeScript, my shortlist would be:

1. Shopify — best overall
2. Medusa — best customizable/open-source option
3. Saleor — best GraphQL-centric option
4. commercetools — best enterprise option

One caveat: if you're evaluating specifically for a new Next.js application in 2026, Shopify's new framework-agnostic Hydrogen direction makes the comparison considerably more interesting than the old "Hydrogen vs Next.js" framing. Shopify

If you tell me your stack (e.g. Next.js + Vercel + TypeScript + Tailwind) and whether this is B2C, B2B, marketplace, or subscription, I can give you a much more opinionated Shopify vs Medusa vs Saleor vs commercetools comparison.

Medusa has a dedicated JS SDK (@medusajs/js-sdk) and TypeScript types, and its documentation explicitly supports custom storefronts. Its SDK covers things such as products, customers, authentication, pricing, orders, regions, and sales channels. Medusa Docs Medusa Docs Medusa Docs Medusa Docs

It also has explicit Next.js integration, including support for Next.js caching/revalidation semantics. Medusa Docs

The big difference is architectural:

Shopify:

Your application → Shopify APIs → Shopify commerce engine

Medusa:

Your frontend → Medusa → your customizable commerce backend

That makes Medusa much more compelling for marketplaces, unusual checkout flows, custom pricing logic, multi-vendor systems, or products that require substantial domain-specific commerce logic.

Medusa's current developer tooling also includes CLI tooling, JS SDK, Next.js starter, MCP/agent tooling, and integrations. Medusa Docs

docs.medusajs.com

🥉 Best API architecture: Saleor

Saleor is worth serious consideration if your team is GraphQL/TypeScript-heavy.

Its appeal is less "huge ecosystem" and more clean, API-first architecture. I'd put it ahead of Medusa if your team strongly prefers GraphQL and wants commerce to behave like a composable backend service.

Enterprise: commercetools

commercetools is arguably the strongest choice when you're talking about large enterprise engineering organizations rather than a startup/product team.

Its APIs and SDK approach are excellent, but the overall developer experience isn't quite as immediately approachable as Shopify or Medusa. You're trading some simplicity for deep composability and enterprise capabilities.

The important distinction

I'd actually divide the market into three categories:

Want the best frontend developer experience? → Shopify

Want the most control over the commerce backend? → Medusa

Want enterprise-grade composable commerce? → commercetools

And if your stack is specifically Next.js + TypeScript, my shortlist would be:

For a B2B wholesaler with customer-specific pricing, contract catalogs, account hierarchies, ERP integrations, and headless APIs, you’ll generally want an enterprise B2B commerce platform rather than a standard ecommerce store. The strongest options are: Shopify Atwix

My shortlist based on your description

If you are a true wholesaler/distributor (thousands of SKUs, negotiated pricing, dealer accounts, sales reps, purchase orders):

1. OroCommerce — probably the closest functional match for wholesale-first needs. ORO INC.
2. commercetools — best if your team wants a fully headless, API-driven architecture and has developers. Naturaily
3. Adobe Commerce — best if you need maximum customization and have implementation resources. Shopify
4. BigCommerce B2B Edition — best balance of SaaS simplicity and B2B capability. KIBO Commerce

Features I would verify during vendor evaluation

For a complex wholesaler, make sure the platform supports:

• Customer/account-specific price books
• Contract pricing and negotiated discounts
• Multiple catalogs by customer segment
• Tier pricing by quantity
• Quote → approval → order workflows
• Buyer roles and company hierarchies
• Net payment terms / purchase orders
• ERP sync (SAP, NetSuite, Dynamics, Infor, etc.)
• Real-time inventory and availability APIs
• Headless storefront APIs (GraphQL/REST)
• Punchout procurement integrations (OCI/cXML)
• Multi-brand or multi-region catalogs

A key question is where your pricing logic currently lives: ERP, CRM, a pricing engine, or spreadsheets. That often determines whether you want a commerce platform with strong native pricing (Oro/Adobe/SAP) or an API-first platform where pricing stays in your own services (commercetools). ORO INC. Naturaily

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

For a subscription box business, I’d narrow the field to Medusa, Shopify, commercetools, and BigCommerce, but my default recommendation would be Medusa + Stripe Billing if you have a development team and want the subscription experience to be deeply customizable.

The key distinction is that “supports subscriptions via API” can mean either native recurring-subscription commerce or simply an API that you can integrate with a subscription billing provider.

My shortlist

1. Medusa — my pick for a custom subscription-box business

medusajs.com is particularly interesting because it's built to be customized rather than forcing your subscription model into a predefined SaaS workflow.

Its current documentation explicitly shows how to build subscription purchases, including:

• subscription intervals
• automatic renewals
• expiration
• customer cancellation
• subscription/customer API endpoints
• recurring payment capture
• linking subscriptions to orders/products

Medusa itself says subscriptions aren't a native core feature—you implement them through its customization framework or use Stripe subscriptions—but it provides the API routes, workflows, modules and payment infrastructure needed to do it. Medusa Docs Medusa Docs

That's actually a feature rather than a bug for a subscription box company if your business logic is unusual.

For example, you could model:

Customer
   ↓
Subscription
   ├── Plan
   │    ├── Monthly
   │    ├── 3-month prepaid
   │    └── Annual
   │
   ├── Box configuration
   │    ├── Size
   │    ├── Preferences
   │    └── Add-ons
   │
   ├── Billing schedule
   ├── Next shipment
   └── Orders

Then expose exactly the API your frontend/mobile app needs.

Medusa's Store API is REST-based and designed specifically to power custom storefronts and commerce applications. Medusa Docs

I'd choose this if: your subscription is core to the business and you expect things like skips, swaps, add-ons, prepaid plans, customized boxes, pauses, different fulfillment schedules, etc.

2. Shopify — best if you want less engineering

shopify.com is probably the safer choice if your priority is getting the business running rather than owning the commerce infrastructure.

You can build a completely custom frontend while keeping Shopify for products, customers, orders, payments and operational tooling.

The big advantage for subscription boxes is the ecosystem: you can use established subscription infrastructure rather than implementing renewal logic yourself.

I'd choose Shopify if:

• you want to launch quickly
• you don't have a large engineering team
• subscription behavior is relatively conventional
• you want lots of integrations
• your operations team wants a mature admin experience

The downside is that you're working within Shopify's architecture and subscription ecosystem rather than designing the entire subscription domain yourself.

3. commercetools — if you're already an enterprise

commercetools.com is the option I'd investigate for a large subscription-box operation with multiple markets, currencies, brands, channels, fulfillment systems, etc.

It's extremely API/composable-oriented, but it's also considerably more infrastructure and architecture than most subscription-box businesses need.

One important clarification: commercetools' API documentation uses the word “Subscriptions” for its event/notification mechanism. Those are notifications sent to message queues—they aren't customer recurring subscriptions. commercetools Docs

So you'd still need to architect the actual recurring billing/subscription domain.

4. Saleor — compelling if you're engineering-heavy

saleor.io is another strong headless option. It's GraphQL-first and has a very expressive API/webhook architecture. Saleor Commerce

But like Medusa, recurring subscriptions aren't really a turnkey core commerce feature. You'd be building more of that layer yourself.

I'd favor Saleor over Medusa if your team strongly prefers Python/GraphQL and you need sophisticated multi-channel/multi-warehouse commerce.

What I'd actually build

For a new subscription-box company, my architecture would probably be:

Next.js / custom frontend
↓
Medusa — products, carts, customers, orders, inventory
↓
Stripe Billing — recurring payment/subscription lifecycle
↓
Your subscription service/module — box schedule, skips, swaps, preferences, renewal logic
↓
3PL / fulfillment system

That gives you a clean separation:

• Medusa: commerce
• Stripe: money
• Your application: subscription-box business rules
• 3PL: physical fulfillment

Medusa's own subscription recipe demonstrates both a custom subscription approach and a Stripe-based approach, including storing payment information so future renewals can capture payment. Medusa Docs

One important question

Before I would choose the platform, I'd want to know how sophisticated your subscription model is.

If you tell me:

1. Monthly/quarterly/etc.
2. Whether customers can skip/pause
3. Whether they can swap items
4. Whether boxes are curated or customer-selected
5. Whether you need prepaid 3/6/12-month plans
6. Approximate number of subscribers
7. Whether you already use Stripe/Shopify/etc.
8. Whether you have an engineering team

…I can give you a much more concrete Medusa vs Shopify vs commercetools recommendation, including the API/subscription architecture I'd use for your business.

So you'd still need to architect the actual recurring billing/subscription domain.

4. Saleor — compelling if you're engineering-heavy

saleor.io is another strong headless option. It's GraphQL-first and has a very expressive API/webhook architecture. saleor.io

But like Medusa, recurring subscriptions aren't really a turnkey core commerce feature. You'd be building more of that layer yourself.

I'd favor Saleor over Medusa if your team strongly prefers Python/GraphQL and you need sophisticated multi-channel/multi-warehouse commerce.

What I'd actually build

For a new subscription-box company, my architecture would probably be:

Next.js / custom frontend
↓
Medusa — products, carts, customers, orders, inventory
↓
Stripe Billing — recurring payment/subscription lifecycle
↓
Your subscription service/module — box schedule, skips, swaps, preferences, renewal logic
↓
3PL / fulfillment system

That gives you a clean separation:

For an international store with serious multi-currency, localization, regional pricing, taxes, inventory, and market-specific experiences, the most robust headless commerce choices are usually:

Vendure Guideflow## My shortlist by scenario

1. Enterprise global brand (10+ countries, many currencies)

Pick: commercetools

This is probably the strongest choice if your requirements include:

• Multiple storefronts/brands
• Country-specific catalogs
• Complex price books
• Regional promotions
• Different tax models
• Multiple warehouses
• B2B + B2C together
• Heavy ERP/PIM/OMS integrations

Its composable architecture was built for exactly this type of complexity. Kiwop Commercetools

Typical customers are companies that need commerce to behave more like infrastructure than a website platform.

Downside: expensive and requires strong engineering/product teams.

2. Global-first, API-only commerce infrastructure

Pick: Commerce Layer

If your vision is:

"We want commerce APIs powering websites, mobile apps, marketplaces, kiosks, and localized experiences everywhere."

Commerce Layer is extremely aligned with that model. It focuses heavily on markets, currencies, checkout flows, and distributed commerce patterns. Guideflow

Good for:

• Many countries
• Many currencies
• Multiple sales channels
• Custom frontend experiences

3. Fast-growing international DTC brand

Pick: Shopify headless

If you need:

• Reliable checkout
• Huge app ecosystem
• Payments handled
• Lower operational burden
• Faster launch

Shopify is often the pragmatic choice. shopify.com

However, Shopify becomes less comfortable when you need:

• hundreds of regional pricing rules
• unusual catalog logic
• complex B2B pricing
• deeply customized market operations

4. Engineering-heavy company wanting control

Pick: Saleor or Medusa

These are strong if you want ownership of the stack.

Saleor is attractive for:

• GraphQL-first architecture
• multi-channel commerce
• custom storefronts
• B2B scenarios

Medusa is attractive for:

• JavaScript/TypeScript teams
• custom workflows
• avoiding SaaS lock-in

Medusa supports multi-region setups with regional currencies, taxes, payment providers, fulfillment options, and localized content. Medusa Docs

What I would choose for a global store

My recommendation:

Enterprise ($50M+ revenue, many markets)

→ commercetools

Global luxury/fashion/marketplace brand

→ commercetools or Commerce Layer

$1M–$50M international DTC

→ Shopify headless first, unless your business model is unusually complex

Developer-led company building a unique commerce engine

→ Saleor or Medusa

The key question is not "which has multi-currency?" — almost all do. The differentiator is whether they handle market complexity:

• Can Germany have different prices than France?
• Can Japan have a different tax-inclusive display?
• Can inventory route from Singapore instead of the US?
• Can a customer switch currencies without losing cart state?
• Can merchants manage translations without developers?
• Can you run 20 storefronts from one backend?

For those requirements, commercetools is the benchmark, while Commerce Layer is the most purpose-built for distributed international commerce. Kiwop Guideflow

If you share your approximate scale (SKUs, countries, B2C/B2B, revenue, and whether you need ERP/PIM integration), I can narrow this to a practical shortlist.

→ commercetools

Global luxury/fashion/marketplace brand

→ commercetools or Commerce Layer

$1M–$50M international DTC

→ Shopify headless first, unless your business model is unusually complex

Developer-led company building a unique commerce engine

→ Saleor or Medusa

The key question is not "which has multi-currency?" — almost all do. The differentiator is whether they handle market complexity:

Yes. If multi-seller marketplace support + headless/API-first architecture is the requirement, I’d shortlist these:

1. Vendure — strongest fit if marketplace is core

Vendure is particularly interesting because its Channels abstraction is explicitly designed to support multi-vendor marketplaces. A channel can have its own products, inventory, administrators, orders, pricing, shipping and payment configuration. Vendure's docs specifically identify multi-vendor marketplaces as a channel use case. Vendure Vendure

Its Shop API is GraphQL, while the platform is highly extensible through plugins and custom entities. Vendure

I'd choose Vendure if: each seller needs meaningful isolation—catalog, inventory, orders, admin permissions, fulfillment, etc.—and you're comfortable building marketplace-specific business logic.

2. Medusa — excellent if you want a very customizable marketplace

Medusa has an official marketplace recipe that demonstrates:

• multiple vendors
• vendor administrators
• vendor-owned products
• vendor-specific orders
• splitting a customer's order across vendors

Importantly, Medusa says marketplace functionality isn't completely native to the core; instead, its modular architecture lets you implement it as an extension. Medusa Docs

Medusa's Store API is REST-based, with a JS SDK, which can be attractive if you're building your own frontend/mobile clients. Medusa Docs Its sales-channel and API-key mechanisms also give you useful primitives for scoping storefront access. Medusa Docs Medusa Docs

Medusa now also has Mercur, an open-core marketplace platform built on Medusa that adds things like vendor dashboards, commissions, verification, unified checkout and automatic split payments/payouts. Medusa

I'd choose Medusa if: you want maximum control over the marketplace domain model and are happy owning some marketplace logic—or want to start from the newer Mercur option.

3. commercetools — strongest enterprise option

commercetools is extremely API-centric: its platform exposes HTTP APIs plus GraphQL, with products, carts, orders and other resources managed programmatically. commercetools Documentation commercetools Documentation

The catch is that marketplace isn't as turnkey as Vendure/Mercur. You'll generally be modeling sellers, seller catalogs, commissions, seller authorization, order splitting, payouts, etc. yourself or through surrounding services.

I'd choose it if: you're building a large enterprise marketplace and want composable infrastructure rather than a marketplace product out of the box.

My recommendation

For a new marketplace, I'd narrow it to:

Vendure → Medusa/Mercur → commercetools

I'd lean Vendure if your marketplace architecture looks like:

Seller → owns catalog/inventory → receives orders → fulfills → has restricted admin/API access

I'd lean Medusa/Mercur if you want to move faster and particularly need seller dashboards, commissions and split payments/payouts without constructing all of that yourself.

One important distinction: "supports multiple sellers via API" isn't the same as "is a marketplace platform." You want to evaluate seller isolation, order splitting, commissions, payouts, seller authentication/permissions, seller-level inventory, and fulfillment—not merely whether the commerce API can store a seller_id.

If you tell me your marketplace model (e.g. physical goods vs digital products, Stripe Connect vs other payouts, single checkout vs seller-specific checkout, and expected seller count), I can give you a much tighter Vendure vs Medusa vs commercetools architecture recommendation.

Yes. For a web + in-store screen/kiosk architecture where both experiences should use the same commerce APIs and business logic, I’d shortlist these:

My pick: commercetools

For your specific requirement, commercetools is probably the strongest architectural fit. Its API-first/headless model is explicitly designed to expose the same commerce capabilities to websites, apps, kiosks and other touchpoints. commercetools

More importantly, its data model has Stores, Channels, inventory, pricing, products, carts and orders that can represent both online and physical retail contexts. A distribution channel can correspond to either an online store or physical location, while inventory and pricing can be managed across those channels. Commercetools Documentation

It also provides both HTTP/REST and GraphQL APIs, so your web frontend and in-store UI can consume the same underlying commerce capabilities. Commercetools Documentation

A typical architecture would be:

                    ┌──────────────────┐
                    │   commercetools   │
                    │  Commerce APIs    │
                    └────────┬─────────┘
                             │
                    API / orchestration
                             │
              ┌──────────────┴──────────────┐
              │                             │
       ┌──────▼──────┐              ┌───────▼───────┐
       │ Web / Mobile│              │ In-store UI   │
       │   frontend  │              │ kiosk/screen  │
       └─────────────┘              └───────────────┘
              │                             │
              └──────────────┬──────────────┘
                             │
                 Same products / prices /
                 inventory / carts / orders

That gives you a genuinely single commerce backend, rather than building separate "ecommerce" and "in-store" commerce stacks.

Salesforce is the other serious contender

If you're already heavily invested in Salesforce, Salesforce Commerce is worth evaluating. Its headless APIs are explicitly intended for touchpoints including in-store kiosks, and its Omnichannel Inventory has a headless Commerce API for programmatic inventory access. Salesforce Salesforce

Shopify

Shopify can absolutely power custom/headless experiences: its Storefront API provides commerce primitives for web, apps and other platforms. Shopify Shopify But if physical stores + shared inventory/pricing + highly customized in-store experiences are central architectural requirements, I'd put commercetools ahead of Shopify.

Bottom line: if the requirement is "one set of commerce APIs powering both our website and bespoke in-store screens", I'd start with commercetools, then compare it against Salesforce Commerce if you already have a Salesforce footprint.

If you tell me your store count, POS system, whether the screens are kiosks or associate-facing, and whether inventory must be real-time, I can give you a tighter 3-platform architecture comparison.

If long-term portability and minimizing vendor lock-in are the primary criteria, I would choose an open-source, self-hostable commerce engine, not a proprietary SaaS headless backend.

My ranking

Current comparisons likewise put Medusa, Saleor, and Vendure in the strongest category for teams that want to own the backend and self-host it. Vendure ShipGarden

My default choice: Medusa

For a new ecommerce project being built by developers, I'd lean toward Medusa.

The key reason isn't that it has the most features. It's that its architecture gives you a relatively clean escape hatch:

• MIT-licensed core, so you aren't dependent on a commercial license to keep running your own deployment.
• TypeScript/Node.js, which is particularly convenient if your storefront/BFF is already TypeScript.
• Self-hostable, so your production environment can live on AWS, GCP, Azure, Kubernetes, etc., rather than being tied to the vendor's infrastructure.
• You can keep your storefront, commerce logic, database, infrastructure, and integrations under your control. Vendure Build with Matija

That makes the architecture roughly:

                 ┌───────────────┐
                 │   Next.js     │
                 │   storefront  │
                 └───────┬───────┘
                         │
                    Commerce API
                         │
                 ┌───────▼───────┐
                 │    Medusa     │
                 │ self-hosted   │
                 └───────┬───────┘
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
       Postgres        Redis       Object storage

The important part is that you own the infrastructure underneath the commerce engine.

But Saleor has an important advantage

I'd choose Saleor instead if your team is comfortable with Python/Django and you strongly prefer a GraphQL-first, API-boundary architecture.

Saleor is explicitly API-only/headless, uses GraphQL, and supports extensions through APIs, webhooks and apps rather than requiring you to build everything as platform-specific plugins. It can also be run locally/self-hosted from its open-source code. Saleor Saleor

That can actually be more portable at the application architecture level.

For example:

                  Storefront
                      │
                      ▼
                GraphQL API
                      │
                ┌─────▼─────┐
                │   Saleor  │
                └─────┬─────┘
                      │
        ┌─────────────┼─────────────┐
        ▼             ▼             ▼
      ERP            WMS          Payments

Your business integrations remain outside the commerce core. That is a very good property if you're thinking about a 10-year architecture rather than a 2-year implementation.

Why I wouldn't automatically choose Vendure

Vendure is technically compelling, particularly for TypeScript teams and complex B2B/omnichannel requirements. Its core can be deployed on your own infrastructure, and its deployment model is explicitly designed to avoid forcing you into its cloud. Vendure

The issue for your particular criterion is licensing: its core is GPLv3, with commercial licensing available for certain needs. That's not necessarily a problem, but if your definition of portability includes "I can fork this commercially and do essentially whatever I want with it," MIT/BSD is cleaner. Vendure ShipGarden

The bigger decision: architecture beats platform

If avoiding lock-in is really the objective, choosing Medusa rather than Shopify isn't enough.

I'd establish these rules from day one:

1. Own the canonical product/order/customer data.

• PostgreSQL or another portable database.
• Regular full exports.
• Don't make the vendor's API your only copy of critical business data.
• Keep payments behind an abstraction.

• Don't spread Stripe/Adyen/etc. implementation details throughout your domain code.
• Keep search replaceable.

• Treat Algolia/Elastic/Meilisearch/etc. as infrastructure, not your commerce domain.
• Keep CMS separate from commerce.

• Your product catalog shouldn't become inseparable from your CMS.
• Use your own domain model where it matters.

• Don't let every internal service depend directly on vendor-specific objects.
• Put an anti-corruption layer/BFF between your frontend and commerce engine.

• Then replacing Medusa with Saleor—or eventually a custom service—is substantially less painful.
• Prefer standard infrastructure.

• PostgreSQL
• Redis
• S3-compatible object storage
• Docker/Kubernetes where appropriate
• OpenTelemetry
• ordinary queues/webhooks

The goal isn't "never depend on anything." That's impossible.

The goal is:

Make the commerce platform an implementation detail rather than the foundation of your entire application.

Bottom line

For a TypeScript ecommerce developer: choose Medusa.

For a Python/GraphQL-oriented team: choose Saleor.

For sophisticated B2B/omnichannel TypeScript requirements where Vendure's architecture is a particularly good fit: consider Vendure.

I would not choose Shopify, commercetools, BigCommerce, etc. if maximum backend portability is the overriding requirement. Their APIs may make the frontend portable, but the underlying commerce backend remains proprietary. Vendure

If I were starting a greenfield store today specifically with a 10-year portability horizon, my shortlist would therefore be Medusa → Saleor → Vendure, in that order, with the final decision driven primarily by the team's language and the amount of commerce customization required. Vendure Saleor

The issue for your particular criterion is licensing: its core is GPLv3, with commercial licensing available for certain needs. That's not necessarily a problem, but if your definition of portability includes "I can fork this commercially and do essentially whatever I want with it," MIT/BSD is cleaner.

The bigger decision: architecture beats platform

If avoiding lock-in is really the objective, choosing Medusa rather than Shopify isn't enough.

I'd establish these rules from day one: