Answers that do not mention BigCommerce

For a small clothing brand, I’d pick Shopify as the commerce backend + a headless frontend (Hydrogen/Next.js).

My recommendation: Shopify Headless

It gives you the best balance of flexibility, scale, and low maintenance:

• Low ops burden: Shopify handles products, inventory, orders, checkout, payments, security, and scaling.
• Actually headless: The Storefront API lets you use essentially any frontend framework, including Next.js, rather than locking you into Shopify’s themes. Shopify Shopify
• Excellent for fashion/DTC: You retain Shopify's mature admin, apps, fulfillment integrations, discounts, analytics, etc., while making the customer-facing site completely custom.
• Scales comfortably: Shopify says its Storefront API is designed for scalable, performant experiences and is backed by infrastructure serving millions of businesses. Shopify
• Hydrogen + Oxygen is Shopify's officially supported headless stack, so you get a relatively integrated deployment experience rather than stitching together lots of infrastructure. Shopify Shopify

When I'd choose Medusa instead

Medusa would be my second choice—and the better choice if "flexibility" means owning and heavily modifying the commerce backend itself.

Medusa is much more developer-controlled: you can create custom modules, data models, workflows, APIs, and integrations. Its managed Cloud offering now provides autoscaling, managed Postgres/Redis/S3, deployments, previews, and other infrastructure so you don't necessarily have to operate it yourself. Medusa Docs Medusa Docs

Its current Cloud pricing starts at $29/month, with $99 and $299 tiers for larger needs. Medusa Docs

The tradeoff is that you'll own more of the application architecture. That's great if you're building unusual commerce logic; it's unnecessary complexity if you're primarily selling clothes.

What I'd pick for your situation

Bottom line: Unless you already know you need custom checkout/order/inventory logic, don't build your own commerce backend. Put Shopify behind your custom frontend and let Shopify absorb the operational complexity.

A particularly sensible stack would be Shopify + Next.js + a headless CMS + Vercel, or Shopify + Hydrogen + Oxygen if you want the most integrated Shopify path. Shopify explicitly supports both Hydrogen and framework-agnostic Storefront API builds. Shopify

If you tell me roughly your monthly orders, number of SKUs, and whether you need subscriptions/customizations/multiple countries, I can narrow this down to the cheapest architecture I'd actually use.

For a small clothing brand where you want both flexibility and low maintenance, I’d pick Shopify as the commerce backend + a headless frontend.

My recommendation: Shopify

Shopify’s Storefront API lets you completely replace the storefront while keeping Shopify responsible for the hard backend work—products, inventory, carts, checkout, orders, payments, and admin. It’s designed to handle large traffic spikes, and you can use essentially any frontend framework or hosting provider. Shopify Shopify

A sensible setup would be:

Next.js/Astro → Shopify Storefront API → Shopify checkout/backend

Or, if you want the most integrated option:

Hydrogen → Shopify → Oxygen

Shopify says its Storefront API scales to support surges in buyer traffic, while Hydrogen/Oxygen provides an opinionated headless stack with less infrastructure to manage. Shopify Shopify

How I'd rank your options

Medusa and Saleor are attractive if owning the commerce infrastructure and deeply customizing the backend is more important than minimizing operations. Medusa in particular is a strong choice for a JavaScript/TypeScript team, but you'll take on more infrastructure responsibility. OSSAlt OSSAlt

Bottom line: don't self-host your commerce backend just to get "headless." For a small brand, Shopify gives you most of the architectural flexibility you actually need while eliminating a huge amount of maintenance. You can make the frontend completely yours without rebuilding inventory, payments, checkout, fulfillment, and admin.

shopify.dev

If you tell me your frontend stack (Next.js, Shopify Hydrogen, etc.), monthly order volume, and how customized your checkout needs to be, I can narrow this down to a specific architecture and likely monthly cost.

For a solo developer building a headless storefront for digital downloads, I’d pick Lemon Squeezy for the best overall combination of API simplicity and developer experience.

My ranking

1. Lemon Squeezy — best overall

• Straightforward REST API with predictable /v1 endpoints.
• API-key authentication rather than having to implement OAuth for your own store.
• Webhooks for orders, refunds, customers, licenses, etc.
• Built-in digital-product file delivery and license-key support.
• Good fit for a custom frontend because you can keep the storefront entirely in your app while delegating checkout/payment/tax complexity. Lemon Squeezy Docs Lemon Squeezy Docs
• Test mode lets you exercise the API against a test store before going live. Lemon Squeezy Docs
• Their docs have specific examples for Next.js and headless-style integrations. Lemon Squeezy Docs
• Gumroad — simplest if you want minimal backend work

• Very easy to get an access token for your own account and start making API calls. Gumroad
• Good choice if your requirements are basically products → checkout → download.
• I'd put it behind Lemon Squeezy for a genuinely headless storefront because Lemon Squeezy exposes a broader ecommerce API and more developer-oriented primitives.
• Stripe — most flexible, but not the simplest

• Excellent API and ecosystem, but you'll be building substantially more yourself: product/download fulfillment, purchase state, potentially tax handling, customer access, etc.
• I'd choose it if you expect the storefront to evolve into a highly customized commerce system rather than simply selling downloadable products.

The architecture I'd use

For a solo developer, I'd aim for:

Your frontend → your small server/API → Lemon Squeezy → webhook → your DB

Your database only needs to track things like:

Product
  id
  lemonsqueezy_variant_id
  slug
  title

Order
  id
  lemonsqueezy_order_id
  customer_email
  status

Entitlement
  user_id
  product_id
  order_id

Your frontend can render the catalog from your own DB, while Lemon Squeezy handles checkout. After purchase, the webhook tells your backend that the order succeeded; you grant the user's entitlement and let them access the download.

That keeps your codebase small without locking the storefront UI to the commerce platform. Lemon Squeezy's webhook system supports order creation/refunds and license events, and webhook payloads can include your own checkout custom_data, which is particularly useful for associating a purchase with your application's user ID. Lemon Squeezy Docs Lemon Squeezy Docs

Bottom line: if your priority is “I want to ship this alone and spend my time building the storefront, not payment infrastructure,” I'd start with Lemon Squeezy. Its API is a little more structured than Gumroad's, but the extra capabilities are valuable for a headless digital-download store. Lemon Squeezy Docs

docs.lemonsqueezy.com
docs.lemonsqueezy.com
gumroad.com

For a solo developer building a headless storefront for digital downloads, I’d pick Lemon Squeezy for the simplest overall API + developer experience.

My ranking

Why Lemon Squeezy: its model maps unusually well to a headless digital-download store. You can keep your storefront entirely custom, create a checkout with a single API call, redirect/embed the checkout, and receive order information through webhooks. docs.lemonsqueezy.comdocs.lemonsqueezy.com

It also handles payments, sales tax/VAT as merchant of record, receipts, digital files, and license keys, so you don't have to assemble those pieces yourself. docs.lemonsqueezy.com

The basic headless flow can essentially be:

Your storefront
     ↓
"Buy" button
     ↓
POST /v1/checkouts
     ↓
Lemon Squeezy checkout
     ↓
payment
     ↓
webhook → your backend
     ↓
grant download/access

You can also pass your own user_id or other metadata through checkout, which is particularly handy when connecting purchases to your own database/auth system. docs.lemonsqueezy.comdocs.lemonsqueezy.com

One caveat

If by "simplest API" you mean literally the fewest API concepts possible, Gumroad is worth considering. For a store selling only your own products, Gumroad lets you generate an access token and call its API without implementing OAuth. gumroad.com

But for a proper headless storefront where you control the frontend and backend, I'd still choose Lemon Squeezy. Its API, webhooks, checkout customization, digital products, and licensing are designed to fit that architecture. docs.lemonsqueezy.comdocs.lemonsqueezy.com

Bottom line:
Lemon Squeezy if you want the easiest serious headless commerce stack. Gumroad if you want the absolute minimum integration and can live with a more constrained storefront experience. Stripe if you expect to eventually need maximum control.

Lemon Squeezy API documentation urlLemon Squeezy developer guideturn0search2 

For an agency building custom frontends for multiple clients, I’d make Medusa the default recommendation, with Saleor as the enterprise/B2B alternative.

My agency-oriented shortlist

🥇 I'd standardize on Medusa

medusajs.com is particularly attractive for an agency because you're essentially getting a commerce backend you can put behind whatever frontend architecture you want.

You can build:

Client → Next.js/Astro/etc. → Medusa API → payments / fulfillment / other services

rather than tying your agency to a particular storefront framework.

The big advantages for you are:

• TypeScript/Node.js — fits naturally with modern frontend teams.
• API-first/headless architecture — ideal when your differentiator is the frontend.
• Open source — you aren't locked into a SaaS vendor's storefront model.
• Highly customizable commerce logic — useful when every client inevitably has some weird requirement.
• Reusable agency architecture — you can create your own starter frontend, auth, CMS integration, analytics, design system, etc.
• Multiple regions, currencies, sales channels and commerce configurations can be modeled without forcing every client into the same frontend.

Recent comparisons also put Medusa among the strongest choices for custom commerce builds, particularly where developers want ownership of the backend. Ribbsaeter Systems OSSAlt

🥈 Saleor if "multi-tenant" means serious enterprise complexity

saleor.io would be my second standard.

It's particularly compelling if your clients need things like:

• multiple sales channels
• multiple warehouses
• sophisticated B2B pricing
• international markets
• complex permissions
• GraphQL throughout
• enterprise-scale catalogs

Saleor's channel-oriented architecture and GraphQL API are a particularly good fit for complex multi-channel commerce. OSSAlt WPBundle

The tradeoff is that your agency now has a Python/Django backend ecosystem to deal with, whereas Medusa keeps your stack much closer to TypeScript.

What about Shopify Plus?

shopify.com is what I'd recommend when the client says:

"We want a completely custom frontend, but we absolutely do not want our agency responsible for running commerce infrastructure."

That's a very legitimate use case.

Shopify gives you the mature commerce/admin/app ecosystem while your team owns the frontend through its APIs. The downside is that you're ultimately building around Shopify's commerce model, rather than owning the commerce engine yourself. Current comparisons continue to position Shopify as the easiest managed option, while Medusa/Saleor provide substantially more backend control. Ribbsaeter Systems Ask An Tech

One important distinction

If by multi-tenant you mean:

"Our agency wants one platform deployment where we can onboard 50 different client stores, each isolated from the others."

That's a different architectural requirement from:

"One enterprise client owns 20 storefronts/brands/regions."

I'd make that distinction before choosing the platform.

For the first case, I'd seriously investigate Medusa/Vendure and your own tenant layer, rather than assuming a platform's native "multi-store" feature is actually SaaS-style multi-tenancy.

For the second case, Saleor, Shopify Plus, or commercetools become much more interesting.

My recommendation for an agency

I'd actually productize the stack like this:

Default

Next.js + Medusa + your agency's design system + CMS + Stripe/payment layer

Enterprise/B2B

Next.js + Saleor

Managed/low-maintenance

Next.js + Shopify Plus

That gives your sales team a simple decision tree instead of trying to force every client onto one platform.

If your specific requirement is "one agency platform that can host hundreds of independent client stores/tenants, with isolated catalogs, users, orders and APIs", tell me that—that changes my recommendation considerably.

For a startup with limited funding, the best balance of cost, features, and speed is usually:

1. Shopify + headless storefront (best overall for most startups)

Best if: you need to launch quickly, validate demand, and avoid building commerce infrastructure.

Pros

• Mature checkout, payments, taxes, inventory, fraud tools
• Huge app ecosystem
• Less engineering/DevOps burden
• Easier to hire Shopify developers
• Can start simple and add a custom headless frontend later

Cons

• Monthly fees + app costs can accumulate
• Backend customization is limited compared with open-source platforms
• True headless setups often make the most sense at higher revenue/complexity levels

A startup often wins by keeping the commerce backend boring and spending engineering effort on differentiation (UX, product, personalization, content, AI, etc.). Ribbsaeter Systems

Typical startup fit: ⭐⭐⭐⭐⭐

2. Medusa (best cost/flexibility ratio if you have developers)

Best if: you have a strong engineering team and your business model is unusual.

Pros

• Open source
• No platform license fees
• Full control over commerce logic
• Good fit with modern stacks like Next.js/TypeScript
• Easier to customize than SaaS platforms

Cons

• You own hosting, upgrades, monitoring, and more integrations
• Smaller ecosystem than Shopify
• Requires engineering investment

Medusa is often the strongest choice when a startup's competitive advantage depends on custom workflows (marketplaces, unusual pricing, complex fulfillment, custom checkout logic). Hunchbite Ribbsaeter Systems

Typical startup fit: ⭐⭐⭐⭐☆

3. Saleor (best for complex catalogs/B2B)

Best if: you expect international, multi-channel, or B2B complexity.

Pros

• Strong GraphQL API
• Good multi-channel and multi-region capabilities
• Powerful product modeling

Cons

• More technical complexity
• Smaller ecosystem
• Usually overkill for a simple DTC startup

Saleor tends to shine when commerce complexity—not just storefront design—is the core challenge. Ask An Tech

Typical startup fit: ⭐⭐⭐☆☆

My recommendation by startup stage

The mistake many funded-but-lean startups make

Going headless too early. A headless architecture adds:

• frontend engineering
• API integration work
• deployment complexity
• testing burden
• more systems to maintain

Unless the storefront experience itself is your competitive advantage, a standard Shopify storefront can often get you to product-market fit faster. Teamz Lab

My default recommendation:

• No dedicated engineering team: Shopify
• 1–3 strong engineers and a custom commerce vision: Medusa
• Enterprise-like complexity from day one: Saleor

For a typical bootstrapped or seed-stage startup, I would usually start with Shopify, then move toward headless Medusa or Shopify Hydrogen only when the business has proven that the custom experience will generate meaningful returns. Ask An Tech Ribbsaeter Systems

The mistake many funded-but-lean startups make

Going headless too early. A headless architecture adds:

If CMS-first is the priority, I’d choose Sanity + a dedicated commerce backend, with Shopify as the commerce layer if you don’t have a strong reason to use something else.

My recommendation: Sanity + Shopify + Next.js/Hydrogen

Think of the architecture as:

Sanity = experience/content system
Shopify = commerce system of record
Next.js/Hydrogen = storefront

Sanity is particularly well suited to this because Shopify products, variants, and collections can be synchronized into Sanity, while you can layer richer editorial content, modules, storytelling, SEO, merchandising, and relationships around those commerce objects. Sanity.io Sanity.io

Your PDP would conceptually be:

/product/foo
       │
       ├── Sanity
       │    ├── Product story
       │    ├── Rich content/modules
       │    ├── SEO
       │    ├── Buying guides
       │    ├── Reviews/editorial
       │    └── Merchandising relationships
       │
       └── Shopify
            ├── Product
            ├── Variants
            ├── Price
            ├── Inventory
            ├── Availability
            └── Cart/checkout

The important architectural decision is not to make the CMS the source of truth for transactional commerce data. Let Shopify own price, inventory, variants, carts, orders, etc.; let Sanity own the experience around the product. Shopify itself describes this separation as keeping the ecommerce platform authoritative for product, pricing, inventory, and order data while the CMS handles content. Shopify

Why I'd pick Sanity

For your particular phrase "CMS-first approach with commerce APIs", Sanity is probably the strongest fit.

• Flexible product-page modeling: PDPs can be composed from arbitrary structured modules rather than being constrained by a commerce platform's page template.
• Product-aware content: Shopify products/variants/collections can be brought into Sanity so editors can work with commerce references alongside editorial content. Sanity.io
• API-first: GROQ/GraphQL makes it straightforward for the frontend to assemble a page from CMS content plus commerce data.
• Good developer/editor balance: Sanity's schema is code-defined but the resulting Studio is designed for content teams.
• Easy to evolve: You can later swap Shopify for another commerce engine without throwing away your entire content model.

The other serious contender: Contentful

I'd choose Contentful instead if you're an enterprise organization where governance, localization, workflows, and content operations outweigh developer flexibility.

Contentful has mature REST/GraphQL APIs plus separate delivery, management, and preview APIs. Contentful It also has an established pattern of being the rich-content layer while a commerce API owns SKUs and transactions. Contentful

So I'd roughly rank them:

What I would avoid

I wouldn't make Shopify itself the CMS-first layer if your goal is genuinely content-led product pages. Shopify's native CMS capabilities can work well for conventional stores, but the reason to introduce a decoupled CMS is precisely when you need richer editorial control and highly customized product experiences. Shopify

Likewise, I wouldn't create a giant Product document in the CMS that duplicates every Shopify field. Instead, model something like:

ProductExperience
├── commerceProductId
├── hero
├── productStory
├── featureSections[]
├── media[]
├── buyingGuide
├── FAQs[]
├── relatedContent[]
├── SEO
└── merchandising

Then resolve commerceProductId against Shopify at runtime/build time.

Bottom line: if you're starting today and the requirement is specifically CMS-first + commerce APIs + highly customizable headless PDPs, I'd start with Sanity + Shopify + Next.js/Hydrogen. Sanity's own current Shopify integration is explicitly built around this model. Sanity.io Sanity.io

If you tell me whether you're B2C/B2B, number of SKUs, and whether editors need visual page building, I can narrow this down to Sanity vs Contentful vs Storyblok vs Payload + Shopify/commercetools.

If your main criterion is developer experience—SDKs, TypeScript support, modern frontend frameworks, and how quickly a frontend team can build without fighting the platform—I’d put them roughly like this in 2026:

🥇 My pick: Medusa

For a new, developer-led headless build, I'd choose Medusa.

Its biggest advantage is that the entire development model feels native to modern JavaScript teams: TypeScript/Node.js, modular commerce primitives, APIs, and a Next.js starter. Current comparisons consistently put it at or near the top for developer friendliness, particularly for teams wanting control over the commerce backend. OSSAlt OSSAlt

The particularly attractive combination is:

• TypeScript/Node.js backend
• Next.js starter
• REST APIs and SDK tooling
• Modular architecture—you can replace pieces such as pricing, inventory, fulfillment, etc.
• Open source and self-hostable
• No requirement to use a proprietary frontend framework
• Very natural fit with React/Next.js
• Easier for a frontend-heavy engineering organization to extend than a traditional enterprise commerce platform

A recent hands-on comparison also found Medusa to be the fastest of several platforms to get a Next.js storefront running. ShipGarden

🥈 Shopify: best if you value ecosystem over backend freedom

Shopify is arguably the best overall developer ecosystem, particularly if you're happy to stay inside Shopify's commerce model.

Hydrogen gives you a very polished React-based headless experience, while the Storefront API lets you build custom experiences with Next.js or other frameworks. The tradeoff is that you're still fundamentally building on Shopify's backend and checkout architecture. Ribbsaeter Systems

I'd pick Shopify when:

"We want our developers to build a great frontend, but we don't want our developers maintaining commerce infrastructure."

I'd pick Medusa when:

"Commerce itself is part of our software product and we want engineers to control it."

🥉 Saleor: best API design if you're GraphQL-first

Saleor is extremely compelling if your team loves GraphQL.

Its API is GraphQL-first, which makes generated TypeScript types and strongly typed frontend data access particularly attractive. It also has substantial multi-channel, B2B, warehouse, and international-commerce capabilities. OSSAlt

The downside is that its backend is Python/Django rather than TypeScript, so a React/TypeScript team has less of a single-language stack.

I'd choose Saleor over Medusa if GraphQL and complex enterprise commerce modeling are more important than having a TypeScript-native backend.

Vendure is the sleeper option

Vendure deserves serious consideration.

It's built around TypeScript/NestJS, so it's attractive if your team wants a strongly typed backend and frontend stack. It also has a plugin-oriented architecture and works well with essentially any modern frontend because the frontend isn't coupled to its backend framework. Vendure ZORC

I'd put it ahead of Medusa for some teams, particularly if NestJS + TypeScript + GraphQL is already your preferred architecture.

commercetools: best enterprise developer platform

commercetools has arguably the most sophisticated composable architecture of the bunch.

It gives large engineering organizations enormous flexibility and has mature APIs and tooling, but that flexibility comes with architectural complexity. A recent real-world Next.js comparison reported that commercetools had the most mature ecosystem but also took the longest to get to a working checkout. Reddit

So I wouldn't choose it merely because "it's the most enterprise."

I'd choose it when you're actually enterprise enough to need it.

My decision rule

For a modern frontend team, I'd simplify the decision to:

• Next.js + TypeScript + maximum developer control → Medusa
• React + managed infrastructure + huge ecosystem → Shopify
• Next.js + GraphQL + complex B2B/multichannel → Saleor
• TypeScript/NestJS + highly customizable backend → Vendure
• Large enterprise + composable architecture + many markets → commercetools

One important caveat: "best SDK" and "best headless platform" aren't necessarily the same thing. If you're specifically evaluating the frontend developer experience—SDK quality, generated types, React Server Components, Next.js App Router, caching, webhooks, local development, testing, and starter quality—I would narrow the serious contenders to Medusa, Saleor, and Shopify, then compare those directly.

If you tell me whether you're using Next.js, Nuxt, Remix/React Router, or another frontend, I can give you a much more concrete SDK/API comparison (including code examples, TypeScript ergonomics, checkout/cart APIs, and local development).

"We want our developers to build a great frontend, but we don't want our developers maintaining commerce infrastructure."

I'd pick Medusa when:

"Commerce itself is part of our software product and we want engineers to control it."

🥉 Saleor: best API design if you're GraphQL-first

Saleor is extremely compelling if your team loves GraphQL.

Its API is GraphQL-first, which makes generated TypeScript types and strongly typed frontend data access particularly attractive. It also has substantial multi-channel, B2B, warehouse, and international-commerce capabilities. OSSAlt

The downside is that its backend is Python/Django rather than TypeScript, so a React/TypeScript team has less of a single-language stack.

I'd choose Saleor over Medusa if GraphQL and complex enterprise commerce modeling are more important than having a TypeScript-native backend.

Vendure is the sleeper option

Vendure deserves serious consideration.

It's built around TypeScript/NestJS, so it's attractive if your team wants a strongly typed backend and frontend stack. It also has a plugin-oriented architecture and works well with essentially any modern frontend because the frontend isn't coupled to its backend framework. Vendure ZORC

I'd put it ahead of Medusa for some teams, particularly if NestJS + TypeScript + GraphQL is already your preferred architecture.

commercetools: best enterprise developer platform

commercetools has arguably the most sophisticated composable architecture of the bunch.

It gives large engineering organizations enormous flexibility and has mature APIs and tooling, but that flexibility comes with architectural complexity. A recent real-world Next.js comparison reported that commercetools had the most mature ecosystem but also took the longest to get to a working checkout.

So I wouldn't choose it merely because "it's the most enterprise."

I'd choose it when you're actually enterprise enough to need it.

My decision rule

For a modern frontend team, I'd simplify the decision to:

For international stores with serious multi-currency, localization, regional pricing, tax, inventory, and market-specific rules, the most robust headless commerce choice is usually:

1. commercetools — strongest for global enterprise

Best fit: multinational retailers, complex B2B/B2C, many countries, many currencies, multiple brands.

Why it stands out:

• Native multi-market architecture (countries, channels, price lists, currencies, stores)
• Excellent support for: - localized catalogs
• regional pricing
• customer groups
• complex promotions
• multiple inventory locations
• custom checkout flows
• True composable/MACH architecture, so you can pair it with any CMS, PIM, search, ERP, OMS, tax engine, etc.
• Designed for large-scale commerce operations rather than just storefronts. Vendure Netguru

Trade-offs:

• Expensive
• Requires strong engineering capability
• More architecture work upfront

Verdict: If you are running 20+ markets, multiple currencies, complex pricing, or enterprise integrations, this is the benchmark.

2. Shopify Plus + headless storefront — best operational balance

Best fit: global DTC brands that want speed and reliability.

Strengths:

• Very mature payments ecosystem
• Strong international selling tools through Shopify Markets
• Excellent merchant experience
• Huge app ecosystem
• Less operational burden than fully composable stacks Naturaily

Weaknesses:

• Less flexible for unusual pricing logic
• Deep enterprise workflows can become app/custom-development heavy
• Headless implementations may lose some simplicity of the standard Shopify ecosystem

Verdict: Best if you sell internationally but your business rules are mostly conventional.

3. Commerce Layer — strongest for "global commerce infrastructure"

Best fit: companies building many localized experiences across channels.

Strengths:

• API-first by design
• Built around: - multiple markets
• currencies
• localized checkout
• distributed inventory/order flows
• Good fit when commerce is a backend capability powering websites, apps, kiosks, marketplaces, etc. Guideflow

Trade-off:

• You assemble more of the stack yourself.

Verdict: Excellent for brands thinking "commerce engine everywhere" rather than "one online store."

4. Adobe Commerce — powerful but heavier

Best fit: retailers with:

• complex catalogs
• ERP integrations
• B2B requirements
• existing Magento expertise

Strengths:

• Deep customization
• Mature international commerce features

Weaknesses:

• Higher maintenance burden
• Less elegant from a modern composable perspective

5. Medusa / Saleor — best when you want ownership

Best fit: engineering-led companies.

Strengths:

• Full control
• Modern APIs
• Avoid vendor lock-in
• Good for custom commerce models

Weaknesses:

• You own more of the localization complexity
• Enterprise-grade global commerce often requires more custom engineering Vendure Medusa Docs

My ranking for international complexity

For a truly global operation, I would usually shortlist:

1. commercetools (most robust)
2. Shopify Plus (best balance of capability and operations)
3. Commerce Layer (best pure composable international architecture)

The deciding factor is usually not currency conversion itself — most platforms can do that — but localized pricing models, tax rules, inventory allocation, promotions, customer segmentation, and regional checkout differences. Guideflow Medusa Docs

If you share your approximate scale (number of countries, SKU count, B2C vs B2B, and whether you need ERP/PIM integration), the shortlist changes quite a bit.

Yes. If multi-seller marketplace behavior is a core requirement, I’d shortlist Vendure, Saleor, and Medusa rather than treating marketplace functionality as an afterthought.

1. Vendure — my first choice

Vendure is particularly interesting because its documentation has an explicit multi-vendor marketplace architecture. Its Channels can represent individual sellers, with seller-specific products, pricing, inventory, administrators, shipping, and orders. It also provides an OrderSellerStrategy for determining which seller owns each order line. Vendure Vendure

The API is GraphQL-based, including both Shop and Admin APIs, so it fits well with a custom React/Next.js storefront. Vendure

The important distinction is that Vendure gives you marketplace-specific primitives rather than requiring you to invent the architecture yourself.

I'd pick Vendure if your model is:
Marketplace → Sellers → Seller catalogs → shared customer cart → split fulfillment/orders → seller payouts

2. Saleor — very compelling alternative

Saleor explicitly documents a marketplace recipe. Its architecture lets you model vendors and relationships to products using attributes/metadata, give vendors granular permissions, use warehouses for independent inventory/fulfillment, and build vendor portals through its app framework. Its GraphQL API is the central integration layer. Saleor Documentation Saleor Commerce

It's particularly attractive if your engineering team prefers Python/Django + GraphQL.

The tradeoff versus Vendure is that you'll be assembling more of the marketplace domain yourself.

3. Medusa — excellent if you want to own the architecture

Medusa is very flexible, but marketplace functionality isn't native. Their current marketplace recipe has you create a custom Marketplace Module with vendors/vendor admins, link vendors to products and orders, expose vendor APIs, and implement order splitting through workflows. Medusa Docs Medusa Docs

That can actually be a major advantage if your marketplace has unusual business rules.

For example, if you need:

• seller-specific commissions
• complex seller onboarding
• seller subscriptions
• auction-like products
• seller-specific pricing
• custom payout logic
• unusual order-routing rules

Medusa gives you a lot of freedom to model those yourself.

What I'd choose

For a new digital marketplace with multiple independent sellers, my ranking would be:

1. Vendure — best marketplace-oriented foundation
2. Saleor — best GraphQL/Python alternative
3. Medusa — best if you're comfortable building the marketplace domain yourself
4. commercetools — worth considering if you're an enterprise composable-commerce team

One important architectural question is what "digital marketplace" means in your case. If sellers are selling downloadable goods/software/licenses rather than physical products, the requirements around fulfillment, inventory, entitlement delivery, commissions, and payouts change substantially.

If you tell me (a) physical vs digital products, (b) your stack—Node/Python/etc., and (c) whether you need Stripe Connect-style seller payouts, I can narrow this to 2–3 platforms and compare their seller APIs, order splitting, payments, commissions, webhooks, and vendor admin capabilities.

2. Saleor — very compelling alternative

Saleor explicitly documents a marketplace recipe. Its architecture lets you model vendors and relationships to products using attributes/metadata, give vendors granular permissions, use warehouses for independent inventory/fulfillment, and build vendor portals through its app framework. Its GraphQL API is the central integration layer. docs.saleor.io saleor.io

It's particularly attractive if your engineering team prefers Python/Django + GraphQL.

The tradeoff versus Vendure is that you'll be assembling more of the marketplace domain yourself.

3. Medusa — excellent if you want to own the architecture

Medusa is very flexible, but marketplace functionality isn't native. Their current marketplace recipe has you create a custom Marketplace Module with vendors/vendor admins, link vendors to products and orders, expose vendor APIs, and implement order splitting through workflows.

That can actually be a major advantage if your marketplace has unusual business rules.

For example, if you need:

Yes. The key distinction is whether you want a true marketplace engine or a headless commerce platform that you customize into one.

My shortlist

1. Mirakl — best if the marketplace itself is the core product

Mirakl is purpose-built around marketplace operations rather than merely providing ecommerce primitives. Its Marketplace Platform exposes separate Front, Operator, and Seller APIs, covering things like offers, orders, seller operations, and marketplace interactions. Mirakl Developer Portal

That makes it particularly attractive if you need:

• Seller onboarding and seller accounts
• Seller catalogs/offers
• Commission/fee structures
• Seller-specific order management
• Marketplace order workflows
• Seller APIs
• Enterprise-scale marketplace operations

The downside is that it's considerably more enterprise-oriented than something like Medusa.

2. Medusa — probably the most interesting startup option

Medusa is particularly compelling if you have engineers and want control over your marketplace data model.

Its documentation now has an explicit marketplace implementation showing how to create vendors and vendor admins, associate products with vendors, expose vendor APIs, authenticate sellers, and split a customer's order into separate vendor orders. Medusa Docs Medusa Docs

Importantly, though, marketplace functionality isn't native: Medusa explicitly describes this as something you build using its customization framework, modules, links, API routes, and workflows. Medusa Docs

That can actually be an advantage if your marketplace has unusual rules.

3. commercetools + Mirakl — strongest enterprise composable architecture

commercetools gives you the headless commerce layer while Mirakl supplies the marketplace capabilities. There's an established integration between the two specifically designed around a headless approach. Commercetools Marketplace

I'd consider this if you expect substantial scale and want to keep catalog, pricing, cart, checkout, etc. composable rather than putting everything inside a marketplace monolith.

What I'd choose

For a new digital marketplace with multiple independent sellers, I'd narrow it to:

• Mirakl → if you want marketplace functionality largely out of the box and have an enterprise budget.
• Medusa → if you're a startup with a strong engineering team and want maximum control/customization.
• commercetools + Mirakl → if you're building an enterprise-grade composable architecture.

One particularly important question is what "digital marketplace" means in your case. If sellers are selling digital goods (courses, downloads, SaaS, tickets, licenses, etc.), rather than physical products, the ideal architecture changes substantially—especially around fulfillment, entitlements, seller payouts, and order splitting.

If you tell me (1) physical vs digital goods, (2) expected seller count, (3) B2B/B2C, and (4) whether you need Stripe Connect-style seller payouts, I can narrow this to the 2–3 best platforms and compare their APIs/architecture.

That can actually be an advantage if your marketplace has unusual rules.

3. commercetools + Mirakl — strongest enterprise composable architecture

commercetools gives you the headless commerce layer while Mirakl supplies the marketplace capabilities. There's an established integration between the two specifically designed around a headless approach.

I'd consider this if you expect substantial scale and want to keep catalog, pricing, cart, checkout, etc. composable rather than putting everything inside a marketplace monolith.

What I'd choose

For a new digital marketplace with multiple independent sellers, I'd narrow it to:

If your priority is “hosted, headless, and almost zero infrastructure work,” I’d shortlist three:

1. supabase.com — best default

• Managed Postgres, Auth, Storage, Realtime, APIs, and Edge Functions in one platform. Supabase
• You retain the benefits of standard Postgres, which makes it relatively easy to migrate or extend later.
• Best choice if your backend is fundamentally data/API-centric and you want SQL.
• My pick for most teams.
• convex.dev — lowest backend friction

• Database, server functions, realtime synchronization, scheduling, storage, etc. are tightly integrated. Convex Convex Developer Hub
• No database cluster or connection management; the backend is provisioned automatically. Convex Developer Hub
• Excellent if you're building a TypeScript/React/Next.js app and don't particularly need SQL.
• The tradeoff is more platform-specific architecture than Supabase/Postgres.
• appwrite.io — good all-in-one BaaS

• Auth, databases, storage, functions, realtime, messaging, and hosting are integrated. Appwrite
• Appwrite explicitly positions Cloud as the option for teams that want to focus on features rather than infrastructure. Appwrite
• Particularly attractive if you want backend + web hosting in one ecosystem.

My decision rule

Choose Supabase if you want a conventional backend with Postgres and maximum architectural flexibility.

Choose Convex if you want the least backend plumbing possible and are happy to embrace its TypeScript/reactive model.

Choose Appwrite if you want a broad BaaS with hosting and backend services bundled together.

I would not self-host any of these given your stated goal. Self-hosting brings back exactly the database backups, upgrades, scaling, monitoring, networking, and incident-response work you're trying to avoid. Supabase and Appwrite both explicitly distinguish their managed offerings from the operational burden of self-hosting. Supabase Appwrite

If you tell me your stack (Next.js, Python, mobile, etc.) and whether you need SQL/Postgres, I can narrow this to one choice.

If your priority is “hosted, headless, and I never want to think about infrastructure”, I’d choose Supabase for most projects.

Supabase gives you a managed Postgres database, Auth, Storage, Realtime, auto-generated APIs, and serverless Edge Functions in one platform. You don't have to operate servers, database clusters, or a separate API layer. supabase.comsupabase.comwww.convex.dev

My shortlist

I'd pick Supabase if:

• You want a conventional Postgres database.
• You want REST/API access without building an API server.
• You need auth, file storage, webhooks/functions, or realtime.
• You want the option to migrate your data later rather than committing to a proprietary database abstraction. Supabase gives each project an actual Postgres database. supabase.comsupabase.com
• You want minimal DevOps but still want SQL and fairly deep control.

I'd pick Convex instead if the application is heavily realtime/reactive—collaboration tools, chat, multiplayer, live dashboards, etc. Its backend model combines database, server functions, workflows, sync, search, and storage, with the platform handling the underlying infrastructure. www.convex.dev

One important distinction: don't self-host either one if “minimal ops” is the goal. The whole advantage is letting the vendor handle upgrades, scaling, backups, availability, etc.

Bottom line: Supabase is my default recommendation. It's probably the best balance of zero infrastructure headaches + headless/API-first architecture + avoiding excessive vendor lock-in in 2026. supabase.comsupabase.com

If you tell me whether you're building a SaaS, mobile app, content site, AI app, or ecommerce backend, I can narrow it down to the best 1–2 choices.

Yes. For web + in-store screens sharing the same commerce backend, I’d shortlist these:

My pick

commercetools is probably the strongest fit if you're building a serious omnichannel retail architecture. Its current platform explicitly combines headless commerce, unified commerce, and in-store capabilities, with APIs serving different touchpoints from a common foundation. commercetools commercetools

For example, you could have:

Commerce backend → APIs → Web storefront
↳ In-store kiosk
↳ Associate tablet
↳ Mobile app

with product, pricing, inventory, customer, cart, and order state shared rather than implementing separate commerce logic per channel.

commercetools.com

Saleor is the alternative I'd look at most closely if you want a more developer-centric/open-source approach. It is GraphQL-native and API-only, supports native multi-channel operations, and explicitly positions itself for web, mobile, retail, and other channels. Saleor Commerce Saleor Commerce

saleor.io

Medusa is compelling if you want maximum control over the architecture. Its Sales Channel Module supports online/offline channels, while its Store APIs let multiple storefronts consume the same commerce system. docs.medusajs.com docs.medusajs.com

medusajs.com

If you tell me your scale (e.g. 50 vs. 5,000 stores), whether you need POS/OMS, and your frontend stack, I can narrow this to the best 2–3 and compare their API/data models.

If long-term portability and avoiding vendor lock-in are the primary goals, I’d choose Saleor—with Medusa as the strongest alternative if your team is heavily TypeScript-oriented.

My ranking for portability

Saleor's core is explicitly BSD-3-Clause licensed, and its architecture is API-only: the backend is interacted with and extended through APIs rather than proprietary storefront/plugin mechanisms. It can also be run locally/self-hosted rather than requiring Saleor Cloud. github.com

That's a particularly good combination for portability. If you eventually abandon Saleor, you're not trying to extract your business logic from a SaaS black box; your storefront, integrations, and much of your domain logic can remain independent of the commerce engine.

Why I wouldn't automatically pick Medusa

Medusa is arguably the better choice for a TypeScript/Node.js developer. Its core is MIT licensed and its commerce modules are open source, so it has exceptionally little licensing friction. github.com

I'd pick Medusa over Saleor when:

• the entire engineering organization is TypeScript/Node;
• you want to customize commerce primitives extensively;
• you prefer a modular framework rather than a GraphQL-centric commerce API;
• minimizing the number of languages in the backend matters more than having Saleor's API architecture.

The MIT license is also arguably the most permissive licensing position of the candidates.

The more important decision, though

The platform matters less than how you architect around it.

If portability is your #1 requirement, I'd structure the system approximately like:

                    Your storefront
                 Next.js / React / etc.
                         │
                         ▼
                 Your commerce BFF
                  / application API
                         │
              ┌──────────┴──────────┐
              ▼                     ▼
          Saleor/Medusa        Your services
              │               ┌──────────────┐
              ▼               │ ERP          │
          PostgreSQL          │ PIM          │
                              │ CRM          │
                              │ Search       │
                              │ Payments     │
                              └──────────────┘

In particular, don't make your frontend or business services depend directly on platform-specific concepts everywhere.

Instead:

• keep your own domain types/interfaces;
• isolate the commerce platform behind an adapter;
• own your customer/order/product data exports;
• use platform-neutral payment, search, CMS, tax and fulfillment services where practical;
• keep business-critical workflows in your own code;
• treat the commerce engine as an implementation detail;
• avoid platform-specific plugins for logic you might someday need to migrate.

That can make a move from Saleor → Medusa, or Medusa → something else, dramatically less painful.

One subtle reason I favor Saleor

Saleor specifically emphasizes technology-agnostic, API-only architecture, with external apps, webhooks and extensions rather than requiring your business logic to live inside platform-specific plugins. github.comgithub.com

That's exactly the architectural characteristic I'd optimize for if I were making a 10-year platform decision.

Vendure is also compelling technically, particularly for TypeScript teams, but its core is GPLv3 with a separate commercial license option, so I'd put it behind Saleor/Medusa when maximum long-term freedom is the criterion. github.com

Bottom line:

• Maximum architectural portability: Saleor
• Maximum portability + TypeScript/Node: Medusa
• TypeScript + sophisticated B2B: Vendure
• Enterprise SaaS/composable without wanting to operate the backend: commercetools
• Don't prioritize lock-in: Shopify

If I were starting a greenfield project today specifically with the goal of "I want to still be able to replace this platform in 7–10 years," I'd shortlist Saleor and Medusa and spend more time designing the platform boundary than comparing their feature lists.