Answers that mention BigCommerce

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

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

The best fit is usually one of these:

powergatesoftware.comribbsaetersystems.com

My recommendation: start with Shopify headless

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

A practical stack:

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

Why:

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

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

When I would pick Medusa instead

Pick Medusa if you expect unusual requirements like:

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

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

What I would avoid initially

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

A sensible growth path:

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

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

Stage 2 (complex operations):

• Add dedicated CMS/search/personalization services

Stage 3 (unique commerce model):

• Consider Medusa, Saleor, or a custom commerce layer

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

For a small clothing brand, I’d start with Shopify + Hydrogen. It gives you a flexible headless frontend while Shopify handles the commerce backend, payments, inventory, checkout, and much of the infrastructure. hydrogen.shopify.dev Shopify

• Shopify/Hydrogen: Best balance of flexibility + low maintenance.
• BigCommerce: Consider if you need more API openness or complex multi-storefront setups. bigcommerce.com
• Medusa/Saleor: More backend control, but substantially more infrastructure/engineering responsibility.

For your priorities—scale without becoming an infrastructure company—Shopify/Hydrogen is the pragmatic choice.

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

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

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

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

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

My practical shortlist

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

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

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

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

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

The deciding question

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

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

A practical shortlist:

Shopify Commercetools## My agency-oriented recommendation

Default recommendation: Shopify headless

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

Why:

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

Architecture:

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

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

If you are building a reusable commerce platform: Medusa

If your business model is closer to:

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

then I would strongly consider Medusa.

You can model:

One Medusa deployment

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

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

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

Typical stack:

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

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

Enterprise clients: commercetools

For large organizations with:

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

I would look at commercetools.

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

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

A platform stack I would standardize as an agency

I would probably create three tiers:

Tier 1 — Marketing/ecommerce brands

Shopify headless + Next.js + CMS

Use for:

• apparel
• beauty
• food
• consumer brands

Tier 2 — Multi-brand / marketplace-style clients

Medusa + Next.js + CMS

Use for:

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

Tier 3 — Enterprise

commercetools + custom frontend

Use for:

• global retailers
• B2B commerce
• complex integrations

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

client1.com
   ↓
tenant_id=client1

client2.com
   ↓
tenant_id=client2

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

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

For an agency building custom frontends for multiple clients, I’d avoid choosing a platform based only on “headless support.” The key question is whether it gives you a repeatable multi-tenant delivery model: one commerce backend strategy, isolated client stores, APIs your frontend team can consume, and operational tooling for non-developers.

Here are the platforms I’d shortlist:

My recommendation by agency model

1. You build 5–50 custom sites/year for different brands
→ Shopify headless is probably the safest default.

Architecture:

Next.js / Remix frontend
        |
Shopify Storefront API
        |
Shopify Admin + apps + integrations

Pros:

• Fast client onboarding
• Merchants already understand Shopify
• Huge app ecosystem
• Lower maintenance burden

Tradeoff:

• Each client is its own Shopify instance; you’re not really operating a multi-tenant SaaS platform.

2. You want “one platform, many client stores”
→ Look at Medusa, Saleor, Spree, or a dedicated multi-tenant commerce backend.

Architecture:

Client Store A ─┐
Client Store B ─┼── Custom Frontend Layer
Client Store C ─┘
                 |
          Multi-tenant Commerce API
                 |
       Catalog / Orders / Customers

This lets your agency build:

• shared frontend components
• tenant-specific branding
• centralized deployments
• reusable integrations
• subscription revenue around hosting/maintenance

3. You serve enterprise clients
→ Consider BigCommerce headless or composable commerce stacks.

Good when clients need:

• multiple regions
• B2B pricing
• ERP integrations
• complex catalogs
• multiple storefront experiences

A stack I’d standardize for a modern frontend agency

Frontend

• Next.js
• React Server Components
• Tailwind/design system
• Vercel or similar hosting

Commerce

• Shopify for standard merchants
• Saleor/Medusa/Spree for platform-style builds

Content

• Contentful, Sanity, or another headless CMS

Search

• Algolia or Elasticsearch/OpenSearch

Payments

• Stripe where possible

If your agency’s goal is “we launch a branded storefront for a new client every month from the same codebase”, I would lean toward a multi-tenant commerce backend (Medusa/Saleor/Spree-style).

If your goal is “we make premium custom storefronts for established brands”, I would standardize on Shopify headless and build your own reusable frontend framework around it.

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

Why I'd look at Medusa first

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

That gives you a useful progression:

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

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

When I'd choose something else

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

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

My practical decision rule

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

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

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

For a startup with limited funding, I’d narrow the shortlist to Medusa, Shopify + Hydrogen, and BigCommerce Catalyst. Based on current 2026 pricing and feature sets, Medusa has the strongest cost/features balance if you have engineering capacity.

My practical recommendation: Medusa

Medusa is particularly attractive when cash is constrained because its current Cloud pricing starts at $29/month, with no GMV/platform fee, unlimited products, orders, sales channels, regions and currencies on the listed plans. You can also self-host the open-source platform. Medusa Medusa

That gives you a useful combination:

• Low fixed cost: $29/month is a much easier starting point than enterprise headless platforms.
• No revenue tax: Medusa says its Cloud plans have a 0% GMV platform fee. Medusa
• Modern developer stack: TypeScript/Node.js and a headless architecture make it well suited to a Next.js-style custom storefront.
• Customization: You aren't constrained to Shopify's underlying commerce model when you need unusual pricing, checkout, marketplace, or fulfillment logic.
• Migration flexibility: You can start on Medusa Cloud and later self-host rather than being completely dependent on the vendor.

The catch is important: Medusa is a developer-oriented platform. You're trading some of Shopify's convenience for lower platform cost and greater control. Your engineering/maintenance cost therefore becomes part of the equation.

When Shopify is actually cheaper

Shopify + Hydrogen can be the better economic choice if your startup has very little engineering capacity.

Hydrogen itself is free, while Shopify provides the underlying commerce infrastructure, payments ecosystem, administration, apps, etc. Shopify App Store

So I'd think about it this way:

• 1–2 strong developers: Medusa is compelling.
• Founder + freelancer / very small technical team: Shopify/Hydrogen may have lower total cost because you spend less engineering time.
• Need unusual commerce logic: Medusa becomes more attractive.
• Need to launch extremely quickly: Shopify/Hydrogen has a strong case.

BigCommerce is the middle ground

BigCommerce currently lists its Core plan at $29/month when billed annually, with higher tiers at $79 and $299/month. Its Catalyst framework provides a Next.js/React headless storefront with GraphQL APIs and prebuilt commerce functionality. BigCommerce BigCommerce

I'd consider it if you want more commerce functionality out of the box than a typical open-source headless stack while still retaining a modern headless frontend.

One I'd eliminate for a cash-strapped startup

Saleor is technically excellent, particularly for GraphQL-heavy and B2B applications, but its managed Cloud pricing has moved well beyond the typical bootstrapped-startup range: the current published entry point is $1,599/month, with higher tiers at $3,999/month. Its OSS version remains available if you're willing to operate it yourself. Saleor Commerce

Bottom line

If you have developers: choose Medusa.

If you don't have developers and need to minimize time-to-launch: choose Shopify + Hydrogen.

If you want a managed middle ground with a strong built-in commerce platform: evaluate BigCommerce + Catalyst.

For a startup where every dollar matters, I'd personally model Medusa Cloud ($29–99/mo) vs. Shopify's total monthly + transaction/app costs, rather than comparing headline subscription prices alone. Medusa's low platform cost can be offset if you need significant custom engineering, while Shopify's higher platform/ecosystem costs can sometimes be cheaper overall when engineering time is scarce. Medusa BigCommerce

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

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

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

My usual enterprise shortlist

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

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

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

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

Questions I would use to narrow it down:

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

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

For an enterprise catalog with thousands of SKUs and complex product models, I’d shortlist commercetools and Elastic Path.

• commercetools — particularly strong for deeply structured catalogs, variants, attributes, localization, and API-driven architectures. Its new Modular Catalog supports up to 10,000 variants per product and exposes variant-level APIs. commercetools commercetools Documentation
• Elastic Path — strong if you need complex B2B pricing, bundles/assemblies, multiple catalogs, and more merchandiser-friendly catalog management alongside headless APIs. Elastic Path Elastic Path
• BigCommerce — has solid headless APIs, but I'd investigate its catalog-model limits carefully for highly complex enterprise product structures. BigCommerce

If your priority is maximum product-model/API flexibility, start with commercetools and Elastic Path.

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

My recommendation

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

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

That gives you an architecture roughly like:

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

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

When I'd choose Medusa instead

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

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

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

For example, if you're building:

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

I'd lean toward Medusa.

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

Where Saleor fits

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

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

A practical decision rule

I'd use this:

Choose Shopify if:

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

Choose Medusa if:

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

Choose Saleor if:

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

Choose commercetools if:

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

One important architectural point

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

I'd generally structure it as:

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

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

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

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

For a custom mobile app frontend (React Native, Flutter, native iOS/Android, etc.), the “best” headless commerce platform is usually the one with the strongest APIs, checkout flexibility, mobile SDK support, and operational fit—not necessarily the one with the best web storefront tools. Headless platforms separate the commerce backend (catalog, cart, orders, payments) from the customer experience layer, which lets a mobile app consume the same commerce APIs as a website or other channels. Naturaily

Here are the strongest options by scenario:

Naturaily Vendure## My typical recommendations

Choose Shopify headless if:

• You are building a consumer shopping app.
• You want to launch quickly.
• Your commerce requirements are fairly standard:

• products
• variants
• discounts
• subscriptions
• payments
• fulfillment

Your app talks to Shopify APIs while Shopify handles much of the commerce complexity. Pointerflow

Choose Medusa if:

• Your app is the product experience (not just a mobile storefront).
• You need unusual flows:

• marketplace logic
• custom checkout
• complex pricing
• custom fulfillment rules
• unique customer journeys

Medusa is attractive when developers want ownership of the commerce layer rather than adapting to a SaaS platform’s model. Vendure

Choose commercetools if:

• This is a large-scale platform.
• You have backend engineers.
• You need:

• multiple countries
• multiple brands
• complex catalogs
• B2B pricing
• ERP/PIM integration
• many sales channels

It is designed for composable commerce architectures where the mobile app is one of many frontends. Naturaily

For a mobile app specifically, evaluate these APIs

Before choosing, check:

• Cart API

• Can users keep carts across devices?
• Can anonymous carts become logged-in carts?
• Checkout API

• Can you build your own checkout screens?
• Or does it force a hosted checkout?
• Customer authentication

• OAuth/social login support
• customer profiles
• saved addresses/payment methods
• Inventory

• real-time stock
• multi-location inventory
• Payments

• native mobile payment support
• Apple Pay / Google Pay compatibility
• Webhooks

• order updates
• inventory changes
• fulfillment notifications
• SDK quality

• official mobile SDKs or good GraphQL/REST documentation

A practical shortlist

For most teams:

1. Startup / DTC mobile shopping app: Shopify headless
2. Custom marketplace or unusual commerce logic: Medusa
3. Enterprise omnichannel app: commercetools
4. Mid-market app with lower operational burden: BigCommerce
5. GraphQL-first engineering team: Saleor

If you tell me:

• your app stack (React Native, Flutter, Swift/Kotlin, etc.),
• expected scale (SKUs, orders/day),
• whether you need subscriptions, marketplace, B2B pricing, or custom checkout,

I can narrow this down to 1–2 platforms.

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

Headless CMS → frontend → commerce APIs

rather than letting the commerce platform own the page model.

My shortlist

What I'd choose

For most teams: Sanity + Shopify + Next.js.

Sanity is particularly well suited to making the product page a CMS document rather than a commerce template. Its current Shopify integration can synchronize products, variants, and collections into Sanity, while letting you layer your own editorial fields and content structures on top. Sanity.io Sanity.io

So you can model a PDP roughly as:

Product Page (Sanity)
├── Commerce product → Shopify
├── Hero
├── Product story
├── Rich media
├── Benefits
├── Specifications
├── Reviews
├── Related content
├── SEO
└── Merchandising modules

Your frontend then combines the CMS content with live commerce data:

Sanity
   │
   ├── editorial content
   ├── page structure
   └── merchandising
          │
          ▼
       Next.js
          │
          ├── Sanity API
          └── Shopify Storefront API
                    │
                    ▼
              cart / checkout

That's a genuinely CMS-first architecture: Shopify owns products, inventory, pricing, cart and checkout; Sanity owns how the product is presented and merchandised. Sanity explicitly supports this pattern, including syncing Shopify products/variants/collections and building custom storefronts with Hydrogen or other frontends. Sanity.io Sanity.io

When I'd use Contentful instead

I'd lean Contentful + Shopify if your organization has a substantial editorial operation, localization requirements, governance/workflows, and lots of structured content types. Contentful's Shopify integration lets editors reference Shopify products, variants and collections directly from Contentful, including resolving them through Contentful's GraphQL API. Contentful Contentful

When I'd use commercetools

If you're building a complex multi-market or composable commerce platform, I'd consider:

Contentful/Sanity + commercetools

rather than Shopify. commercetools exposes HTTP and GraphQL APIs specifically for things such as product-detail pages, carts, inventory and orders. commercetools Documentation Contentful also has a native commercetools integration for referencing and previewing products/categories within content. Contentful

One architectural rule I'd strongly recommend

Don't duplicate the source of truth for commerce data.

For example:

Sanity
  owns:
  - product storytelling
  - page composition
  - editorial descriptions
  - buying guides
  - SEO
  - merchandising modules
  - campaigns

Shopify
  owns:
  - SKU
  - price
  - inventory
  - variants
  - availability
  - discounts
  - cart
  - checkout
  - orders

The CMS can reference those commerce objects, but shouldn't become a second inventory/catalog system.

If you tell me your scale (e.g. 1k vs 100k products), whether you need B2B/multi-market, and whether the frontend is Next.js, I can narrow this to a specific architecture and API/data model.

For a CMS-first approach (where the CMS owns the product page experience, storytelling, layouts, SEO content, merchandising blocks, etc., while commerce APIs provide products, pricing, inventory, cart, and checkout), I’d usually avoid making the commerce platform your page builder. Instead, pick a headless CMS + commerce engine combination. Shopify Shopify

The best choice depends on how much commerce complexity you have:

Strong default: Sanity + Shopify

Best for: DTC brands, editorial-heavy stores, premium products, marketing teams.

Architecture:

• Sanity → product storytelling, landing pages, campaigns, rich content models
• Shopify → catalog, inventory, checkout, payments, orders
• Next.js/Astro/Remix → storefront

Why it works:

• Editors get a flexible CMS experience.
• Merchants keep Shopify’s mature commerce workflows.
• Product pages can be assembled from CMS components while referencing Shopify products via IDs/API. Shopify supports this style of headless architecture through its APIs. Shopify

Choose this if your PDPs look like:

• hero media
• editorial copy
• comparison tables
• reviews
• guides
• FAQs
• bundles
• brand storytelling

Enterprise content-heavy: Contentful + Shopify or BigCommerce

Best for: global brands, multiple channels, complex governance.

Contentful works well when you need:

• localization
• structured workflows
• many content types
• multiple frontends

BigCommerce is also strong here because it exposes commerce capabilities through APIs and supports CMS integrations such as Contentful. BigCommerce

Commerce API-first: commercetools

Best for: large enterprises building a true composable stack.

Stack:

• commercetools
• Contentful/Sanity/Storyblok
• custom frontend

Pros:

• Maximum flexibility
• Strong domain modeling
• Good for complex catalogs, B2B, multiple regions

Cons:

• Requires more engineering ownership.

Developer-centric/open-source: Medusa

Best for: teams that want control.

Medusa gives you:

• commerce APIs
• custom workflows
• extensibility

Good fit for:

• marketplaces
• unusual checkout logic
• custom fulfillment models

More operational responsibility than Shopify/BigCommerce.

My shortlist by scenario

A common mistake in CMS-first builds is putting canonical product data (SKU, price, inventory, variants) into the CMS. I’d generally keep that in commerce and let the CMS own the experience layer. Bedrock Labs

A reference model:

CMS
 ├── Product storytelling
 ├── Page layouts
 ├── SEO metadata
 ├── Editorial blocks
 └── Campaign content

Commerce API
 ├── Product IDs
 ├── Variants
 ├── Pricing
 ├── Inventory
 ├── Cart
 └── Checkout

Frontend
 ├── PDP templates
 ├── Components
 └── Personalization

If you’re building SEO-heavy product pages with hundreds/thousands of SKUs, my default recommendation would be Sanity + Shopify + Next.js unless you have enterprise requirements that justify commercetools.

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

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

A shortlist that fits that architecture well:

Naturaily BigCommerce Vendure## My practical grouping

If you want “JAMstack with minimal ops”

Choose:

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

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

If your frontend team is the core differentiator

Choose:

• commercetools

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

If your team wants to own the stack

Choose:

• Medusa
• Saleor

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

A typical JAMstack commerce stack

A common architecture looks like:

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

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

My default shortlist for your stated preference

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

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

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

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

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

How I'd narrow it down

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

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

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

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

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

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

Strengths:

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

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

Tradeoff:

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

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

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

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

Strengths:

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

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

Tradeoff:

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

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

3. Saleor — best GraphQL-centric developer experience

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

Strengths:

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

Tradeoff:

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

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

4. BigCommerce — best managed SaaS API option

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

Strengths:

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

Tradeoff:

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

5. commercetools — best for enterprise composable architecture

commercetools is designed for large organizations assembling multiple commerce services.

Strengths:

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

Tradeoff:

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

My practical ranking by frontend developer experience

For a Next.js + TypeScript team:

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

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

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

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

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

Shopify

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

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

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

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

shopify.dev

Medusa

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

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

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

docs.medusajs.com

commercetools

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

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

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

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

docs.commercetools.com

Saleor

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

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

My practical takeaway

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

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

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

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

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

shopify.dev

Medusa

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

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

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

docs.medusajs.com

commercetools

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

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

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

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

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

Adobe Commerce

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

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

For a wholesaler with rules like:

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

Adobe Commerce is worth serious consideration.

BigCommerce B2B Edition

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

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

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

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

Shopify Plus B2B

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

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

My practical shortlist

If your requirements are primarily:

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

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

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

For a wholesaler with rules like:

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

Adobe Commerce is worth serious consideration.

BigCommerce B2B Edition

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

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

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

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

Shopify Plus B2B

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

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

My practical shortlist

If your requirements are primarily:

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

How I’d narrow it down

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

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

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

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

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

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

Features I’d require in your evaluation checklist

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

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

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

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

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

The shortlist I’d consider:

Shopify BigCommerce## My usual recommendation by stage

1. Growing subscription box brand: Shopify headless

For most subscription boxes, I would start here.

Why:

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

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

Typical stack:

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

This is usually the lowest operational risk.

2. More API control: BigCommerce headless

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

Strengths:

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

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

Potential downside:

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

3. Enterprise composable: commercetools

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

Good when you need:

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

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

4. Maximum control: Medusa or custom stack

Good if your team wants to own the entire system.

You may build:

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

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

What I would choose for a subscription box specifically

A rough decision tree:

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

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

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

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

For a subscription-box business with a headless storefront and an API-first architecture, I’d narrow the field to commercetools + a subscription/payment layer, or a subscription-native platform depending on how much commerce logic you want to own.

The main options

My take for a subscription box

commercetools is particularly interesting now. Its Recurring Orders API is no longer just experimental: it became generally available in September 2025. It lets you create recurring orders through the API and supports daily, weekly, and monthly schedules, custom recurring prices, and lifecycle operations such as pausing, skipping, modifying, and canceling. Commercetools Documentation Commercetools Documentation

That maps pretty well to a box business:

Your frontend
     ↓
Your backend / API
     ↓
commercetools
 ├── Products
 ├── Customers
 ├── Cart / Checkout
 ├── Recurring Orders
 └── Orders
     ↓
Payment provider
     ↓
Fulfillment / 3PL

It also supports mixing one-time products and subscription items in the same checkout. Commercetools Documentation

The important caveat is that commercetools is composable, so you're taking on more architectural responsibility. If your business revolves heavily around subscription-specific functionality—skip a month, swap products, change address, retry failed payments, subscriber portal, churn management, etc.—I'd seriously evaluate Recharge alongside commercetools rather than assuming the native recurring-order functionality covers everything you need.

What I'd choose based on your situation

• You have a strong engineering team and want maximum control: commercetools.
• Subscriptions are the core of the business and you want mature subscription lifecycle tooling: Recharge.
• You want to launch quickly and don't need an extremely custom commerce architecture: BigCommerce + a subscription provider.
• You already have Shopify infrastructure/ecosystem expertise: Shopify + a subscription app/API.

For a box business specifically, I'd evaluate commercetools vs. Recharge first. The key question isn't simply "does it have a subscription API?"—it's whether the API handles your entire subscription lifecycle without forcing you to build a billing engine yourself.

If you tell me (1) your expected number of subscribers, (2) whether boxes are fixed or customers customize them, (3) Stripe/other payment processor, and (4) your frontend stack, I can give you a much more concrete architecture and compare commercetools vs Recharge vs Shopify/BigCommerce for your use case.

That maps pretty well to a box business:

Your frontend
     ↓
Your backend / API
     ↓
commercetools
 ├── Products
 ├── Customers
 ├── Cart / Checkout
 ├── Recurring Orders
 └── Orders
     ↓
Payment provider
     ↓
Fulfillment / 3PL

It also supports mixing one-time products and subscription items in the same checkout. Commercetools Documentation

The important caveat is that commercetools is composable, so you're taking on more architectural responsibility. If your business revolves heavily around subscription-specific functionality—skip a month, swap products, change address, retry failed payments, subscriber portal, churn management, etc.—I'd seriously evaluate Recharge alongside commercetools rather than assuming the native recurring-order functionality covers everything you need.

What I'd choose based on your situation

• You have a strong engineering team and want maximum control: commercetools.
• Subscriptions are the core of the business and you want mature subscription lifecycle tooling: Recharge.
• You want to launch quickly and don't need an extremely custom commerce architecture: BigCommerce + a subscription provider.
• You already have Shopify infrastructure/ecosystem expertise: Shopify + a subscription app/API.

For a box business specifically, I'd evaluate commercetools vs. Recharge first. The key question isn't simply "does it have a subscription API?"—it's whether the API handles your entire subscription lifecycle without forcing you to build a billing engine yourself.

If you tell me (1) your expected number of subscribers, (2) whether boxes are fixed or customers customize them, (3) Stripe/other payment processor, and (4) your frontend stack, I can give you a much more concrete architecture and compare commercetools vs Recharge vs Shopify/BigCommerce for your use case.

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

A practical ranking by scenario:

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

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

When I would choose something else

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

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

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

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

If international selling, multi-currency, localization, and long-term robustness are the priorities, I’d put commercetools at the top of the shortlist.

How I’d think about the major options

Why commercetools stands out

Its underlying model is particularly well suited to multiple countries behaving differently, rather than simply having a translated storefront.

You can model multiple:

• countries/markets
• currencies
• languages
• localized product information
• price lists
• tax configurations
• shipping methods
• customer segments
• channels
• B2B/B2C pricing

Its API explicitly supports configuring multiple countries, currencies, and languages within a project. commercetools Documentation

That's important because international commerce usually gets complicated at the pricing/tax/fulfillment layer, not just the frontend translation layer.

Where I'd choose the others

Saleor is probably the strongest alternative if you want an open-source/GraphQL-first architecture. Its channel model maps nicely to situations like US/USD, UK/GBP, Germany/EUR, etc., with separate pricing, availability and shipping configuration. Born Digital OSSAlt

BigCommerce is attractive if you want considerably more of the operational infrastructure managed for you. It supports multi-storefront, multiple currencies and localized storefronts from a common backend. BigCommerce BigCommerce

Shopify Plus becomes compelling when the priority is minimizing commerce-platform engineering rather than maximizing architectural control. Headless Shopify gives you a custom frontend while retaining Shopify's commerce infrastructure.

Medusa is particularly interesting if your team is TypeScript-heavy and you want ownership/customization. Its region model handles local currency, taxes, shipping and payment options, and its translation capabilities can support localized product experiences. Medusa Medusa Docs

My practical recommendation

If you're building something like:

one global commerce backend → 10–50+ countries → different currencies/prices/taxes/languages/payment methods → Next.js frontend → potentially B2B + B2C

I'd shortlist commercetools vs Saleor first.

If you're more like:

international DTC brand → several markets → need to launch quickly → don't want a large commerce engineering team

I'd investigate Shopify Plus vs BigCommerce.

If you're:

engineering-heavy company → TypeScript → unusual business logic → want to own/control the backend

I'd investigate Medusa.

One important distinction: "multi-currency" isn't enough. For a genuinely international implementation, I'd evaluate each platform on localized price books, currency-specific rounding, tax-inclusive/exclusive pricing, market-specific catalogs, translations, domains, payment methods, shipping, inventory/warehouses, and B2B price lists. That's where the platforms diverge substantially.

If you tell me roughly number of countries, B2B vs B2C, SKU count, and whether you're using Next.js, I can give you a much more concrete architecture comparison of commercetools vs Saleor vs Shopify Plus vs Medusa.

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

For your specific architecture

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

That lends itself to an architecture like:

Commerce backend → common API layer →

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

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

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

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

My architectural shortlist would therefore be:

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

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

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

My shortlist

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

What I'd choose for a developer prioritizing portability

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

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

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

Medusa → your PostgreSQL database → your infrastructure

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

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

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

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

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

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

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

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

My practical decision rule

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

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

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

Medusa → your PostgreSQL database → your infrastructure

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

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

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

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

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: