ChatGPT answers, unedited

If you’re a developer building a custom frontend and your priorities are maximum flexibility + strong APIs, I’d look less at “which has the prettiest storefront” and more at the commerce engine’s API model, extensibility, data ownership, and how much of the backend you’re willing to own. Elogic Commerce Vendure

My shortlist:

PowerGate Software Naturaily## My recommendations by architecture

1. If you want the most freedom: Medusa or Saleor

For a team that wants to build something unique (custom checkout, unusual catalog logic, marketplaces, custom pricing rules), I’d start here.

Medusa

• Node.js/TypeScript friendly
• Modular commerce backend
• Easy fit with Next.js, React, Remix, Nuxt, etc.
• You can modify the backend instead of working around it

Good choice if your stack is modern JavaScript/TypeScript. CozyCommerce Vendure

Saleor

• GraphQL-native
• Strong channel/multi-region concepts
• Good for teams that like strongly typed APIs

Good choice if your frontend team prefers GraphQL workflows. Naturaily

2. If you need enterprise-grade composability: commercetools

This is closer to a “commerce operating system” than a traditional ecommerce platform.

Strengths:

• API-first from the ground up
• Excellent for multiple brands, regions, storefronts, and channels
• Designed for custom architectures

Weakness:

• You need engineering maturity. You are assembling more of the stack yourself. Vendure

3. If you want custom frontend but don’t want to run commerce infrastructure: Shopify or BigCommerce

These are good when you want:

• Managed checkout
• Payments handled
• Admin tools
• App ecosystem
• Less backend maintenance

Shopify’s Storefront API and headless tooling work well for custom storefronts, but the commerce backend remains Shopify’s system rather than something you fully control. Shopify

BigCommerce is often attractive to developers who want SaaS convenience with relatively open APIs. Vendure

For a typical modern stack (Next.js + custom UI), I’d rank them like this:

1. Medusa — best balance of developer freedom and practicality
2. commercetools — best if you’re building enterprise-scale infrastructure
3. Saleor — best if you want GraphQL everywhere
4. BigCommerce — best managed SaaS compromise
5. Shopify — best if business operations matter more than backend control

The biggest question is: do you want to customize the commerce engine itself, or only replace the storefront?

• Replace storefront only → Shopify / BigCommerce
• Build a differentiated commerce platform → Medusa / Saleor / Vendure
• Build global enterprise commerce infrastructure → commercetools

If you tell me your stack (Next.js? React Native? Vue? backend language?), catalog complexity (simple products vs B2B/pricing rules), and whether you need self-hosting, I can narrow it down.

If flexibility + API control are your top criteria, I’d shortlist Medusa, Saleor, Vendure, and commercetools. For a developer building a genuinely custom frontend, the choice mostly comes down to how much of the commerce backend you want to own.

Medusa

For a TypeScript/Next.js developer, I'd look particularly closely at Medusa.

Its current architecture is modular: products, carts, pricing, inventory, orders, payments, fulfillment, promotions, etc. are separate commerce modules, and you can extend their data models and build your own workflows. Medusa Docs Medusa Docs

The API is also straightforward for a custom frontend: Medusa exposes separate Store and Admin REST APIs, provides a JS SDK, and publishes an OpenAPI specification. Medusa Docs Medusa Docs

Most importantly for your use case, the storefront is completely separate from the backend. You can build it from scratch with Next.js, React, mobile, or another frontend rather than adapting your UI to a platform's storefront model. Medusa Docs

I'd choose Medusa when you want:

• TypeScript end-to-end
• Full control over checkout/business logic
• Custom product/catalog models
• Custom pricing/promotions
• Custom APIs and integrations
• Self-hosting
• A backend you can actually modify rather than merely configure

Saleor

Saleor is particularly interesting if you prefer GraphQL.

Its API is GraphQL-first, and its architecture is deliberately headless: storefront and admin experiences are API-driven, with extensions through APIs and webhooks rather than requiring platform-specific frontend plugins. Saleor Documentation Saleor Commerce

I'd investigate Saleor if your frontend/BFF architecture is heavily GraphQL-oriented or you need sophisticated multi-channel, international, B2B, or marketplace capabilities.

Vendure

Vendure is another strong option if you want TypeScript on the backend but prefer a GraphQL/plugin-oriented architecture.

It's worth comparing directly with Medusa if your team wants to own the commerce backend rather than use a SaaS commerce service.

commercetools

commercetools is the one I'd examine for a larger enterprise project.

Its APIs include both HTTP and GraphQL, and its documentation specifically recommends using general APIs behind a middleware/BFF layer for custom frontends to maximize control. commercetools Documentation commercetools Documentation

The tradeoff is that you're buying into a much more enterprise-oriented platform rather than getting a lightweight codebase you can freely modify.

My practical decision tree

If you're a JS/TS developer building a custom Next.js frontend:
→ Medusa

If you want GraphQL everywhere:
→ Saleor

If you want TypeScript + GraphQL + a plugin architecture:
→ Vendure

If this is a large enterprise/composable-commerce project:
→ commercetools

If you mainly want a managed backend and don't want to operate commerce infrastructure:
→ Shopify headless

For your particular wording — "I'm a developer building a custom frontend" + "flexibility and APIs" — I'd start by prototyping Medusa vs Saleor, rather than starting with Shopify. The architectural difference is significant: Medusa gives you a TypeScript/REST-oriented backend you can modify deeply, while Saleor gives you a GraphQL-first API boundary with a more API/application-extension-oriented model. Eryx Innovations Lab Saleor Commerce

If you tell me Next.js/React vs another frontend, expected catalog size, B2C vs B2B, and whether you want to self-host, I can narrow this down to the architecture I'd use and show the API flow for product → cart → checkout → payment → order.

For a developer building a custom frontend, the “best” headless commerce platform depends mostly on how much of the commerce engine you want to own. The strongest options today fall into a few categories. vendure.ionaturaily.com

ribbsaetersystems.com

My shortlist for a developer-first custom frontend

1. Medusa — probably the best balance of freedom + developer experience

Choose Medusa if you want:

• A Next.js/React frontend
• Full control over checkout, pricing, promotions, fulfillment
• A Node/TypeScript stack end-to-end
• The ability to modify the backend instead of fighting platform constraints

Architecture is closer to “commerce primitives you assemble” than a traditional SaaS store. It’s a strong choice when your product is not a standard Shopify-style catalog. hunchbite.comossalt.com

Typical stack:

Next.js frontend
        |
        |
Medusa API
        |
Postgres + payment/shipping integrations

2. Saleor — best if you love GraphQL

Choose Saleor if:

• Your frontend team prefers GraphQL
• You have complex product models
• You need multi-region, multi-channel, B2B capabilities
• You’re comfortable with Python/Django

Its API model is very clean for frontend developers because the storefront consumes a strongly structured GraphQL API. hunchbite.comossalt.com

3. commercetools — best for enterprise-scale composable commerce

Choose this when:

• You have many systems (ERP, PIM, CMS, loyalty, pricing engines)
• Commerce is one service in a larger architecture
• You have enterprise engineering resources

It gives enormous flexibility but usually requires more architecture work. vendure.ionaturaily.com

4. Shopify headless — best when you want to ship, not build commerce infrastructure

A custom frontend on Shopify gives you:

• Excellent checkout reliability
• Payments, tax, fraud, inventory, admin tooling
• Huge ecosystem

The tradeoff is that your backend customization is constrained by Shopify’s model. vendure.ionaturaily.comwww.askantech.com

If I were choosing for a new custom frontend project:

• Solo developer / small engineering team: Medusa
• GraphQL-first team: Saleor
• Enterprise architecture: commercetools
• Brand wants custom UX but doesn’t want commerce ops headaches: Shopify headless
• Marketplace or unusual checkout flows: Medusa or Saleor

For a modern stack like Next.js + React + TypeScript, I’d start by evaluating Medusa vs Saleor vs Shopify Storefront API. The deciding question is:

“Do I want to customize the commerce engine itself, or only customize the customer experience?”

If you need to rewrite commerce behavior → Medusa/Saleor.
If you mainly need a custom storefront → Shopify headless is often enough. ribbsaetersystems.com

I can also give you a developer-focused comparison of APIs, auth models, webhooks, checkout flows, and Next.js integration patterns if that’s the direction you’re building.

If you’re a developer building a custom frontend and your priorities are maximum flexibility + strong APIs, I’d generally rank the options differently than a business buyer would. The “best” choice depends on whether you want to own the commerce backend or just consume a powerful managed API. Guideflow Vendure

My shortlist for developer-first headless commerce

Naturaily Vendure## My recommendations by scenario

1. You want maximum control → Medusa

I’d look at Medusa first for a developer-built product.

Good if you want:

• Next.js / React storefront
• custom checkout logic
• unusual product models
• marketplace behavior
• your own infrastructure
• full control over backend code

It feels closer to a commerce framework than a traditional ecommerce platform. CozyCommerce

Stack example:

Next.js frontend
        |
        |
Medusa API
        |
Postgres + custom services

2. You love GraphQL → Saleor

Saleor is attractive if your frontend team wants a strongly typed API and excellent data querying.

Strengths:

• GraphQL-native
• clean developer experience
• great fit for React/Next.js
• good for custom storefronts

Tradeoff:

• you’ll likely spend more time adapting the platform to unusual business rules. Guideflow

3. You’re building enterprise-scale → commercetools

commercetools is one of the strongest API-first commerce platforms.

Choose it if you need:

• multiple regions
• complex pricing
• B2B workflows
• multiple storefronts
• composable architecture

Tradeoff:

• expensive
• requires experienced engineering teams
• you assemble more pieces yourself Guideflow

4. You want commerce solved, not built → Shopify headless

Shopify with a custom frontend is a pragmatic choice.

Great for:

• DTC brands
• subscriptions
• payments
• inventory
• apps/integrations
• launching quickly

The downside:

• you don’t own the backend model
• some deeply custom flows become workarounds Shopify

My ranking for a developer building a custom frontend

If I were choosing purely as an engineer:

1. Medusa — best balance of flexibility + developer experience
2. Vendure — excellent if you’re a TypeScript/NestJS shop
3. Saleor — best GraphQL-first option
4. commercetools — best enterprise API architecture
5. Shopify headless — best operational simplicity
6. BigCommerce headless — good middle ground

Naturaily VendureA few questions would change the recommendation:

• Are you building B2C, B2B, marketplace, subscriptions, or something custom?
• Are you using Next.js/React, Vue/Nuxt, mobile apps, or something else?
• Do you want to self-host, or is SaaS acceptable?

If flexibility + API control are your top priorities and you're building the frontend yourself, my first choice would be Medusa.

My shortlist

1. medusajs.com — my pick

Medusa is particularly attractive if you're a developer who wants to own the commerce application's architecture rather than merely consume it.

Its current architecture gives you:

• A modular TypeScript/Node.js backend
• REST Store and Admin APIs
• Ability to create your own API routes
• Custom data models/modules
• Custom workflows and business logic
• PostgreSQL
• Independently hosted frontend
• Integrations that can be swapped out rather than being permanently coupled to the platform Medusa Docs Medusa Docs Medusa Docs

The important distinction is that Medusa doesn't just give you APIs—you can extend the backend itself. Its modules, workflows, and API routes are designed specifically for customization. Medusa Docs Medusa Docs

For example, if your business eventually needs:

Product
  ├── custom configurator
  ├── dynamic pricing
  ├── B2B purchasing rules
  ├── external ERP inventory
  ├── custom fulfillment
  └── proprietary checkout logic

you're not necessarily fighting the platform's data model. You can build modules and workflows for those requirements.

Its Store API is REST-based and has an OpenAPI specification, which is convenient if you're building your own frontend or generating API clients. Medusa Docs

2. saleor.io — strongest alternative

I'd seriously consider Saleor if you specifically prefer GraphQL.

Saleor is GraphQL-first and provides APIs for products, checkout, channels, promotions, payments, etc., while also having an extension/app architecture. Saleor Documentation

I'd lean Saleor over Medusa if:

• You strongly prefer GraphQL
• Your frontend has complex data requirements
• You need sophisticated multi-channel commerce
• Your team is comfortable with Python/Django
• You want commerce logic exposed primarily through an API boundary

Medusa makes more sense to me for a JavaScript/TypeScript team that expects to modify the commerce engine itself.

3. commercetools.com — enterprise choice

If you're building something large and enterprise-grade, commercetools deserves consideration.

Its APIs are extremely comprehensive, and its documentation explicitly recommends using its general APIs behind a middleware layer when you're building a custom frontend because that gives you more control over the customer experience. commercetools Documentation

The tradeoff is that you're buying into a considerably more complex composable architecture.

I'd choose it when the project looks more like:

Custom frontend
       ↓
Experience/API layer
       ↓
commercetools
 ├── pricing
 ├── catalog
 ├── cart
 ├── orders
 ├── promotions
 └── B2B
       ↓
ERP / PIM / OMS / tax / payments / etc.

rather than a relatively self-contained ecommerce application.

4. shopify.com — easiest operationally

Shopify is surprisingly good for headless development. Its Storefront API is GraphQL and supports products, collections, carts, checkout, etc. Shopify

You can also bring essentially any frontend stack; Shopify explicitly supports using its APIs with your own technology and hosting choices. Shopify

But there's an important distinction:

Shopify gives you a highly capable commerce service. Medusa gives you a commerce platform you can modify.

If your goal is to build something unusual, that distinction becomes very important.

What I'd choose

For a developer building a custom frontend from scratch, I'd rank them:

Medusa → Saleor → commercetools → Shopify

if your primary criterion is how much control you have.

I'd change the ranking to:

Shopify → Medusa → Saleor → commercetools

if your primary criterion is how little infrastructure you want to operate.

And if you're specifically a TypeScript/Next.js developer, I'd start with Medusa. Its independently hosted storefront model and TypeScript framework make it a particularly natural fit for a custom frontend. Medusa Docs Medusa Docs

If you tell me your expected catalog size, B2C/B2B, subscriptions, multi-vendor requirements, and whether you want to self-host, I can narrow this down to a concrete architecture and recommend the API stack I'd use.

If flexibility + APIs are your top criteria, my shortlist in 2026 would be:

1. Medusa — best overall for a TypeScript/Node developer
2. Vendure — best if you want GraphQL + a highly extensible TypeScript framework
3. Saleor — best if you specifically want GraphQL and have a Python/Django backend preference
4. commercetools — best for enterprise-scale composable commerce, but substantially more expensive/complex

My pick: Medusa

For a developer building a custom frontend, I'd lean toward Medusa.

Its architecture is unusually developer-oriented: commerce functionality is split into modules and workflows, and you can add your own modules, data models, API routes, workflows, and integrations. Medusa Docs Medusa Docs

The API layer is also straightforward: Medusa exposes REST Store APIs, provides a JS SDK, and lets you create arbitrary custom REST endpoints. Medusa Docs Medusa Docs

That makes a stack like:

Next.js / React / mobile app
          ↓
     Medusa API
          ↓
 ┌─────────────────────┐
 │ Products            │
 │ Cart / Checkout     │
 │ Pricing             │
 │ Orders              │
 │ Customers           │
 │ Inventory           │
 └─────────────────────┘
          ↓
 Custom modules / workflows
          ↓
 PostgreSQL + external services

particularly attractive.

You also aren't locked into their frontend. Medusa explicitly treats the storefront as a separate application, so you can build it from scratch with whatever frontend stack you want. Medusa Docs

How I'd choose

Vendure is the strongest alternative I'd investigate. Its Shop API is GraphQL, and its plugin system lets you extend the GraphQL schema, add database entities, integrate external systems, respond to events, and implement custom business logic. Vendure Vendure Vendure

Saleor is compelling if you want GraphQL as the fundamental API rather than REST. Its docs expose a GraphQL API reference and emphasize channels, checkout, multi-region, custom shipping, marketplaces, and application extensions. Saleor Documentation

The practical decision

If I were starting a greenfield custom commerce frontend:

• Next.js + TypeScript → Medusa
• Next.js + GraphQL everywhere → Vendure
• Python/Django backend team → Saleor
• Multi-brand/global enterprise with a dedicated platform team → commercetools
• You don't want to operate commerce infrastructure → Shopify

The important distinction is that Medusa/Vendure/Saleor are closer to commerce frameworks you can shape, whereas Shopify is primarily a commerce SaaS that you consume through APIs.

For your particular description—"I'm a developer building a custom frontend"—I'd start with Medusa vs Vendure, and I'd probably choose Medusa unless GraphQL is a hard requirement. Medusa's low-level modules/workflows give you a lot of room to make the backend behave like your commerce system rather than merely configuring someone else's. Medusa Docs Medusa Docs

docs.medusajs.com
docs.vendure.io
docs.saleor.io

If you tell me Next.js vs another frontend, B2C vs B2B, and whether you need subscriptions/marketplace/multi-vendor, I can narrow it down to one and show you the architecture I'd use.

How I'd choose

Vendure is the strongest alternative I'd investigate. Its Shop API is GraphQL, and its plugin system lets you extend the GraphQL schema, add database entities, integrate external systems, respond to events, and implement custom business logic.

Saleor is compelling if you want GraphQL as the fundamental API rather than REST. Its docs expose a GraphQL API reference and emphasize channels, checkout, multi-region, custom shipping, marketplaces, and application extensions.

The practical decision

If flexibility + API quality are your top criteria, I’d shortlist Medusa, Saleor, and commercetools rather than defaulting to Shopify.

My ranking

🥇 I'd pick Medusa for a developer-owned custom frontend

Medusa is probably the best fit if by "flexibility" you mean I want to be able to change the commerce engine itself rather than work around SaaS constraints.

Medusa separates the storefront from the commerce backend, so your frontend can be essentially anything. Its V2 Store API and Admin API are REST-based, and the framework lets you create your own API routes, data models, workflows, modules, and integrations. Medusa Docs Medusa Docs Medusa Docs

That's particularly attractive if you're building something like:

Custom Next.js / React / mobile app
              │
              ▼
        Your BFF / API layer
              │
       ┌──────┴──────┐
       ▼             ▼
    Medusa       Other services
       │
 ┌─────┼──────────┐
 ▼     ▼          ▼
Cart  Orders   Inventory

You aren't forced to make your frontend conform to a prebuilt storefront architecture. Medusa Docs

🥈 Saleor if you want an exceptionally clean API

Saleor is arguably the more elegant choice if API design is your #1 concern.

It's API-only and GraphQL-native, with storefront and admin functionality exposed through APIs. It also has strong primitives for multi-channel commerce, webhooks, apps, custom attributes, and extensions. Saleor Documentation Saleor Commerce

I'd choose Saleor over Medusa if your team really likes GraphQL and you want your frontend/BFF to have fine-grained control over queries.

🏢 commercetools if you're building enterprise infrastructure

commercetools is the one I'd investigate for a large enterprise build.

Its APIs include both HTTP APIs and GraphQL, with APIs for products, carts, orders, payments, customers, etc. commercetools Documentation commercetools Documentation

It's extremely composable, but you're paying for that enterprise capability in both money and architectural complexity. For a small team building a custom storefront, I'd generally start with Medusa or Saleor.

What I'd choose based on your situation

• "I want maximum control and I'm comfortable owning backend code" → Medusa
• "I want the cleanest API-first/GraphQL architecture" → Saleor
• "We're an enterprise team and commerce is a major platform capability" → commercetools
• "I want headless but don't want to own much infrastructure" → Shopify
• "I want managed SaaS but more open headless APIs than Shopify" → BigCommerce

For a new custom frontend today, my default stack would be:

Next.js/React + Medusa + PostgreSQL + your preferred CMS + Stripe/Adyen + dedicated search

That gives you considerably more architectural freedom than building around Shopify while avoiding the complexity of jumping straight to commercetools.

If you tell me your stack (Next.js/React/etc.), expected SKU/order volume, B2C vs B2B, and whether you want to self-host, I can give you a much more concrete Medusa vs Saleor vs commercetools recommendation.

Custom Next.js / React / mobile app
              │
              ▼
        Your BFF / API layer
              │
       ┌──────┴──────┐
       ▼             ▼
    Medusa       Other services
       │
 ┌─────┼──────────┐
 ▼     ▼          ▼
Cart  Orders   Inventory

You aren't forced to make your frontend conform to a prebuilt storefront architecture. Medusa Docs

🥈 Saleor if you want an exceptionally clean API

Saleor is arguably the more elegant choice if API design is your #1 concern.

It's API-only and GraphQL-native, with storefront and admin functionality exposed through APIs. It also has strong primitives for multi-channel commerce, webhooks, apps, custom attributes, and extensions. docs.saleor.io saleor.io

I'd choose Saleor over Medusa if your team really likes GraphQL and you want your frontend/BFF to have fine-grained control over queries.

🏢 commercetools if you're building enterprise infrastructure

commercetools is the one I'd investigate for a large enterprise build.

Its APIs include both HTTP APIs and GraphQL, with APIs for products, carts, orders, payments, customers, etc.

If you’re a developer building a custom frontend and your priorities are maximum flexibility + strong APIs, I’d narrow the field to a few platforms rather than the usual “best ecommerce platform” lists. The right choice depends on whether you want to own the commerce backend or consume a managed service. Guideflow Vendure

My shortlist

Guideflow Vendure## My picks by scenario

1. You want maximum control: Medusa

I’d probably start here for a modern custom build.

Why:

• Open source
• Node.js/TypeScript ecosystem
• Modular architecture
• Easy to customize checkout, pricing, fulfillment, inventory, promotions
• Good fit with Next.js, React, mobile apps, custom experiences

Tradeoff:

• You own more infrastructure and architecture decisions.

Good fit:

• DTC brands with unusual requirements
• Marketplaces
• Custom B2B flows
• Teams that don’t want a black-box backend

CozyCommerce PowerGate Software

2. You want a beautiful API developer experience: Saleor

If your team loves GraphQL, Saleor is very attractive.

Strengths:

• GraphQL-first
• Strong typing
• Clean separation between storefront and commerce engine
• Great for highly custom storefronts

Tradeoff:

• You need more engineering maturity than a Shopify-style setup.

Guideflow

3. You’re a TypeScript shop: Vendure

Vendure deserves attention if your stack is Node/TS.

Strengths:

• Built with TypeScript
• Plugin architecture
• GraphQL APIs
• Good extensibility model

It feels closer to building your own commerce platform than configuring one.

Vendure

4. Enterprise-scale composable commerce: commercetools

For companies with:

• multiple brands
• multiple regions
• complex pricing
• B2B workflows
• large engineering teams

This is one of the strongest API-first options.

Tradeoff:

• You assemble more pieces yourself.
• Cost and implementation complexity are significantly higher.

Guideflow Vendure

5. You want less backend work: Shopify headless

Shopify is excellent if:

• checkout reliability matters
• merchants need a mature admin
• you want apps/integrations
• you don’t want to maintain commerce infrastructure

But:

• The backend model is still Shopify’s.
• Deeply custom commerce logic can become awkward.

Naturaily Vendure

My recommendation for a developer building a custom frontend

I’d rank them:

1. Medusa — best overall for developer freedom
2. Saleor — best GraphQL experience
3. Vendure — best TypeScript-native option
4. commercetools — best enterprise option
5. Shopify headless — best if business operations matter more than backend freedom

A common modern stack I’d consider:

• Frontend: Next.js / React
• Commerce: Medusa or Saleor
• CMS: Sanity or Contentful
• Search: Algolia or Elasticsearch/OpenSearch
• Payments: Stripe
• Hosting: Vercel + managed backend/cloud

The biggest question is: are you trying to build a unique commerce experience, or a custom frontend on top of a mostly standard store? That answer usually decides between Medusa/Saleor/Vendure vs Shopify/BigCommerce.

If your priority is maximum frontend freedom + strong APIs, I’d shortlist Saleor, Medusa, and commercetools. For a developer-led build, my default pick would be Saleor if you like GraphQL, or Medusa if you want a TypeScript/Node stack.

My recommendation

1. Saleor — best pure API/frontend flexibility

Saleor is particularly attractive for a custom frontend because its storefront and admin are fully headless, with a native GraphQL API, webhooks, multi-channel support, and technology-agnostic extensions. Saleor Commerce Saleor Commerce

Its API model is especially nice if you're building something like:

Next.js → BFF/API layer → Saleor → payments / search / CMS / ERP

You aren't forced into a particular frontend framework, and the GraphQL schema gives you strong typing and precise data fetching. Saleor Documentation

I'd choose Saleor if: your team is comfortable with GraphQL/Python and you expect significant custom commerce behavior.

2. Medusa — best for TypeScript developers

Medusa is probably my pick if your entire stack is JavaScript/TypeScript. Its V2 Store API is REST-based and exposes the commerce functionality needed to build a custom storefront or mobile application. It also provides a JS SDK and OpenAPI specification. Medusa Docs

The big advantage is that you're working with a commerce backend that feels much more like something you can own and customize rather than a SaaS platform you have to work around.

I'd choose Medusa if: you're building with Next.js/React/Node and expect custom pricing, checkout, fulfillment, marketplace, or other business logic.

3. commercetools — best when "flexibility" means enterprise composability

If you're building a serious enterprise platform, commercetools is arguably the strongest option. It provides both HTTP and GraphQL APIs, SDKs, OAuth-based API clients, and a very broad commerce domain model. Commercetools Documentation Commercetools Documentation

Interestingly, their own documentation recommends using a middleware/BFF layer for custom frontends, which is a good architectural pattern for a sophisticated frontend anyway. Commercetools Documentation

The downside is complexity and enterprise pricing.

What I'd pick for a new custom frontend

• Next.js + TypeScript + maximum control: Medusa
• GraphQL-first architecture: Saleor
• Large enterprise / complex B2B / composable architecture: commercetools
• Want excellent commerce infrastructure but don't want to operate it: Shopify
• Want managed SaaS but more API freedom than Shopify: BigCommerce

For a developer building the frontend yourself, I would not automatically choose Shopify just because it's popular. The interesting decision is really Saleor vs. Medusa vs. commercetools.

If you tell me your stack (Next.js/React/etc.), B2C vs B2B, expected catalog/order volume, and whether you want to self-host, I can give you a much more concrete architecture recommendation—including API quality, checkout customization, webhooks, auth, search, payments, CMS, and migration/lock-in.

Its API model is especially nice if you're building something like:

Next.js → BFF/API layer → Saleor → payments / search / CMS / ERP

You aren't forced into a particular frontend framework, and the GraphQL schema gives you strong typing and precise data fetching. Saleor Documentation

I'd choose Saleor if: your team is comfortable with GraphQL/Python and you expect significant custom commerce behavior.

2. Medusa — best for TypeScript developers

Medusa is probably my pick if your entire stack is JavaScript/TypeScript. Its V2 Store API is REST-based and exposes the commerce functionality needed to build a custom storefront or mobile application. It also provides a JS SDK and OpenAPI specification. docs.medusajs.com

The big advantage is that you're working with a commerce backend that feels much more like something you can own and customize rather than a SaaS platform you have to work around.

I'd choose Medusa if: you're building with Next.js/React/Node and expect custom pricing, checkout, fulfillment, marketplace, or other business logic.

3. commercetools — best when "flexibility" means enterprise composability

If you're building a serious enterprise platform, commercetools is arguably the strongest option. It provides both HTTP and GraphQL APIs, SDKs, OAuth-based API clients, and a very broad commerce domain model.

If flexibility + API quality are your top priorities, I’d shortlist Medusa, Saleor, commercetools, and Shopify—but they optimize for very different things.

My ranking for a custom frontend

🥇 Medusa — my pick for maximum developer control

Medusa is probably the strongest choice if you're building a frontend where you don't want the commerce platform dictating your architecture.

Its Store API is REST-based, has an OpenAPI specification, and Medusa lets you create your own API routes, data models, modules, workflows, and integrations. The storefront itself is completely separate from the backend, so you can use essentially any frontend stack. Medusa Docs Medusa Docs Medusa Docs

I'd choose it if you're comfortable with TypeScript/Node.js and expect things like:

• Custom product/catalog models
• Complex pricing
• Custom checkout/business logic
• External ERP/CRM integrations
• Multiple sales channels
• Custom customer experiences
• Your own APIs sitting alongside commerce APIs

Architecture:
Custom frontend → Medusa API → commerce modules/database → external services

🥈 Saleor — excellent if you love GraphQL

Saleor is particularly attractive if your frontend team wants a clean GraphQL-first API.

Saleor exposes its core commerce functionality through GraphQL queries/mutations and has a strong extension/app model. It also has built-in concepts for channels, multi-region commerce, promotions, payments, shipping, and marketplaces. Saleor Documentation Postman

I'd lean Saleor over Medusa if your frontend architecture is heavily GraphQL-oriented.

🏢 commercetools — best for serious enterprise composability

commercetools is arguably the most powerful option here from a pure composable-commerce/API architecture perspective.

It provides both HTTP APIs and GraphQL, with APIs covering products, carts, orders, customers, payments, etc. commercetools Documentation commercetools Documentation

The downside is that it's much more enterprise-oriented. You'll generally have more infrastructure, architecture, and cost considerations than with Medusa or Saleor.

🛒 Shopify — best if you want the commerce infrastructure managed

Shopify is the option I'd choose if frontend flexibility is important but you don't want to own the commerce backend.

Its Storefront API supports products, collections, carts, checkout, etc., and you can use it from essentially any frontend stack. Shopify explicitly supports bringing your own headless stack rather than requiring Hydrogen. Shopify Shopify

Hydrogen is Shopify's opinionated React Router-based option, but it's not mandatory. Shopify Shopify

The tradeoff is that you're still operating within Shopify's commerce model rather than having complete control over the backend.

What I'd choose

If you told me:

"I'm a developer. I'm building a completely custom frontend and I want the backend to stay out of my way."

I'd pick Medusa.

If you said:

"My entire frontend architecture is GraphQL and I want a really nice commerce API."

I'd pick Saleor.

If you said:

"We're building a large enterprise composable architecture."

I'd pick commercetools.

If you said:

"I want the least operational burden and a huge commerce ecosystem, but my frontend must be completely custom."

I'd pick Shopify + Storefront API.

For a new developer-led project, my default would be Medusa. Its combination of an independent frontend, REST/OpenAPI APIs, and the ability to extend the actual commerce backend gives you considerably more architectural freedom than a typical SaaS commerce platform. Medusa Docs Medusa Docs

If you tell me your frontend stack (Next.js, React, Vue, Svelte, mobile, etc.), database/backend preference, and whether this is B2C/B2B, I can narrow it down to a specific architecture and API strategy.

If flexibility + APIs are your top priorities and you're building the frontend yourself, my shortlist in 2026 would be:

My pick: Medusa

For a developer building a completely custom frontend, I'd lean toward Medusa.

Its architecture is particularly attractive if you want to own the application rather than adapt your application to the commerce platform. The storefront is completely separate from the backend, and you can use whatever frontend stack you want. Medusa Docs Medusa Docs

The big advantage is that Medusa isn't just an API sitting in front of a fixed SaaS data model. You can add:

• Custom API routes
• Custom data models
• Custom modules
• Custom workflows/business logic
• Third-party integrations
• Events/webhooks
• Custom admin functionality

That makes it unusually suitable when your commerce requirements aren't completely standard. Medusa Docs Medusa Docs

For example, you could have:

                 Your Frontend
              Next.js / React / etc.
                       │
                       ▼
                 Your BFF/API
                       │
              ┌────────┴────────┐
              ▼                 ▼
          Medusa API       Custom APIs
              │                 │
       ┌──────┼──────┐          │
       ▼      ▼      ▼          ▼
    Catalog  Cart   Orders   Your Domain Logic
       │      │      │
       └──────┼──────┘
              ▼
          PostgreSQL

That's a very developer-friendly architecture if you expect the frontend to become more than a conventional storefront.

When I'd choose Saleor instead

Saleor is probably the stronger choice if GraphQL is a major requirement.

Saleor is API-only and GraphQL-native, with its catalog, checkout, channels, promotions, payments, etc. exposed through its GraphQL API. It also has strong extension mechanisms through apps, webhooks and API extensions. Saleor Documentation GitHub

So if your ideal frontend looks like:

query Product($id: ID!) {
  product(id: $id) {
    name
    variants {
      id
      pricing {
        price {
          amount
        }
      }
    }
  }
}

I'd seriously consider Saleor.

The tradeoff is that you're buying into its Python/Django + GraphQL architecture, whereas Medusa fits especially naturally into a TypeScript/Node stack.

When I'd choose commercetools

If you're building for a large enterprise, I'd put commercetools near the top.

It has both HTTP APIs and GraphQL, with extensive API capabilities around commerce resources and enterprise-oriented composable architecture. commercetools Documentation

I'd choose it when you're expecting things like:

• Multiple brands
• Multiple countries/regions
• Complex pricing
• Multiple sales channels
• ERP/PIM/OMS integrations
• Large distributed engineering teams
• Very high transaction/catalog complexity

For a smaller team, though, it's considerably more platform than you may need.

My decision rule

I'd simplify it to:

TypeScript + maximum control → Medusa

GraphQL + sophisticated commerce model → Saleor

Enterprise composable architecture → commercetools

Don't want to operate commerce infrastructure → Shopify

For a new custom frontend that you're personally building, I'd start with Medusa vs Saleor, and I'd probably choose Medusa unless you specifically prefer GraphQL or need Saleor's particular commerce capabilities.

One important distinction: API flexibility isn't the same as business-logic flexibility. A platform can have an excellent API while making it painful to change checkout, pricing, promotions, order workflows, etc. Medusa's modular/workflow architecture is why I'd give it the edge for a developer who says "I want maximum flexibility." Medusa Docs

If you tell me your stack (e.g. Next.js + TypeScript + PostgreSQL) and whether you need B2B, subscriptions, marketplace/multi-vendor, multi-region, or complex pricing, I can give you a much more opinionated architecture recommendation.

If you're building for a large enterprise, I'd put commercetools near the top.

It has both HTTP APIs and GraphQL, with extensive API capabilities around commerce resources and enterprise-oriented composable architecture.

If your priority is maximum frontend freedom + strong APIs + ability to customize commerce behavior, my default pick would be Medusa.

My shortlist

🥇 I'd choose Medusa for your use case

Medusa is particularly compelling if you're building the frontend yourself rather than wanting the commerce platform to dictate the application architecture.

Its storefront is completely separate from the backend, so you can use Next.js, React, Vue, a mobile app, or essentially whatever you want. Its Store API is REST-based, and you can create your own API routes as well. Medusa Documentation Medusa Documentation

More importantly, the backend itself is extensible. You can add:

• Custom data models/modules
• Custom REST endpoints
• Custom workflows
• Custom business logic
• Custom integrations
• Custom admin functionality
• Extensions to existing commerce models

That's a fundamentally different level of control from "here's an API, please build everything around our assumptions." Medusa Documentation Medusa Documentation

For example, if your product eventually needs:

Custom Frontend
      │
      ▼
Your BFF / API layer
      │
      ▼
Medusa
 ├── Products
 ├── Pricing
 ├── Cart
 ├── Checkout
 ├── Orders
 ├── Inventory
 ├── Payments
 └── Your custom modules
       ├── Subscriptions
       ├── Configurator
       ├── Marketplace
       └── Custom pricing engine

Medusa is designed to let you put that custom commerce logic inside the commerce application, rather than building an increasingly large external middleware layer. Medusa Documentation

docs.medusajs.com

🥈 Consider Saleor if you strongly prefer GraphQL

Saleor is probably the most interesting alternative if your frontend architecture is GraphQL-centric.

Its APIs are GraphQL-first, and it has particularly good concepts around channels, multi-region commerce, checkout, promotions, payments, and extending the commerce model. Saleor Documentation

I'd lean Saleor over Medusa if your team says:

"We want a strongly typed GraphQL API and don't want to work with REST."

I'd lean Medusa if they say:

"We want to own and modify the commerce backend."

docs.saleor.io

🏢 commercetools if you're building serious enterprise commerce

commercetools is arguably the strongest choice if you're building for a large organization with complex B2B/B2C requirements and don't mind enterprise pricing/complexity.

It provides both HTTP and GraphQL APIs and has extensive extensibility mechanisms including custom fields, custom objects, API extensions, subscriptions, and states. commercetools Documentation commercetools Documentation

The downside is that you're buying into a much more elaborate composable-commerce ecosystem. For a small team building a novel product, I'd probably take Medusa's simpler developer experience instead.

docs.commercetools.com

The important distinction

If I were choosing specifically for a custom frontend, I'd rank them:

Medusa → Saleor → commercetools → Vendure → Shopify

But that's not a ranking of overall ecommerce platforms.

It's a ranking for:

"I'm a developer. I'm building my own frontend. I want the backend to give me commerce primitives and APIs rather than dictate my application."

If you tell me your stack (Next.js/React/etc.), expected traffic/order volume, B2B vs B2C, and whether you want self-hosted or SaaS, I can narrow this down to Medusa vs Saleor vs Vendure vs commercetools and give you an architecture recommendation.

If flexibility and API quality are your top priorities, I’d shortlist Medusa, Saleor, and commercetools. My default choice for a developer building a genuinely custom frontend would be Medusa.

My ranking

🥇 Medusa — my pick for maximum developer freedom

docs.medusajs.com

Medusa is particularly attractive if you're comfortable owning some backend infrastructure. It's a Node/TypeScript commerce framework rather than simply a SaaS storefront API. You can add custom modules, data models, workflows, API routes, event subscribers, and customize the admin. Medusa Docs Medusa Docs

That distinction matters if you're building something like:

• custom pricing/quoting
• unusual checkout flows
• marketplace/multi-vendor logic
• subscriptions
• complex fulfillment
• custom customer/account models
• commerce integrated deeply with your own application

Its Store and Admin APIs are REST-based, with OpenAPI documentation and a JS SDK. Medusa Docs Medusa Docs

Why I'd choose it: your frontend isn't constrained by the commerce platform, and your backend isn't constrained to whatever extension points a SaaS vendor gives you.

🥈 Saleor — excellent if you're GraphQL-first

docs.saleor.io

Saleor is probably my choice if you specifically want a GraphQL-native commerce backend.

Its API is GraphQL-first, and the platform has strong concepts around channels, checkout, promotions, multi-region commerce, payments, and extensibility through apps. Saleor Documentation Postman

I'd seriously consider Saleor for:

Next.js/Astro frontend → GraphQL → Saleor → external services

It's especially compelling when your frontend needs to request very specific slices of commerce data and you want GraphQL's type system and query model.

The tradeoff versus Medusa is architectural: Saleor generally encourages extending the system through its API/app architecture, whereas Medusa lets you customize more directly inside the commerce application.

🥉 commercetools — best if you're building enterprise commerce

docs.commercetools.com

If you're building for a large organization with serious requirements around composable architecture, multiple markets, complex catalogs, B2B, integrations, and scalability, commercetools is arguably the strongest platform here.

It exposes both HTTP APIs and GraphQL, with OAuth-based API clients and extensive API tooling. commercetools Documentation commercetools Documentation commercetools Documentation

The downside is that it's a much more substantial enterprise platform. If you're a small development team building a new product, you may be paying for complexity you don't need.

What about Shopify?

shopify.com

I'd choose Shopify headless when operational simplicity and ecosystem matter more than having complete backend control.

It's hard to beat Shopify when you want:

Custom React/Next.js frontend + proven commerce backend + payments + admin + huge app ecosystem.

But if your thinking is "I want the commerce backend to behave like infrastructure that I can mold around my application," I'd lean toward Medusa or Saleor instead.

The decision I'd make

If you told me only:

"I'm a developer. I'm building a custom frontend. I care about flexibility and APIs."

I'd pick:

1. Medusa — best overall for maximum customization in a TypeScript stack
2. Saleor — best if you strongly prefer GraphQL
3. commercetools — best for serious enterprise/composable commerce
4. Shopify — best when minimizing backend/ops work is more important than control

One particularly important distinction: don't choose based on the storefront API alone. Look at how you'll implement the next 20% of your requirements that don't fit the default commerce model. That's where Medusa/Saleor/commercetools diverge dramatically.

If you tell me your stack (e.g. Next.js + TypeScript + Postgres) and whether this is DTC, B2B, marketplace, subscriptions, or something unusual, I can narrow it down to one and show you the architecture I'd use.

If flexibility + APIs are your top priorities and you're building the frontend yourself, I’d shortlist Medusa, Saleor, and commercetools.

My ranking

🥇 I'd pick Medusa for a developer-built frontend

Medusa is particularly compelling if you want the commerce backend to feel like part of your application rather than a SaaS box you integrate with.

Medusa has a REST Store API, but more importantly, its framework lets you create your own API routes, data models, modules, workflows, and business logic. The frontend can be a completely independent application using whatever stack you want. Medusa Docs Medusa Docs Medusa Docs

That's a very good fit for something like:

Next.js / React / Vue / Svelte
            │
            ▼
       Your BFF/API
            │
       ┌────┴─────┐
       ▼          ▼
    Medusa      Your services
       │
 ┌─────┼───────────────┐
 ▼     ▼       ▼       ▼
Cart  Orders  Catalog  Payments

You retain a lot of control over the backend instead of bending your frontend around the commerce platform.

docs.medusajs.com

🥈 Saleor if you love GraphQL

Saleor is arguably the better choice if GraphQL is a major architectural requirement.

Saleor is API-only and GraphQL-native, with the storefront and admin exposed through APIs. It also has strong multi-channel capabilities and an extension model based around apps, webhooks, metadata, and API extensions. docs.saleor.io Saleor Commerce GitHub

So I'd lean:

• TypeScript/Node + maximum ability to modify commerce behavior → Medusa
• GraphQL + strongly API-oriented architecture → Saleor
• Large enterprise + sophisticated composable architecture → commercetools

docs.saleor.io

🏢 commercetools for serious enterprise

commercetools is extremely API-centric and supports both HTTP APIs and GraphQL. It is designed around composable commerce rather than giving you one monolithic ecommerce application. commercetools Documentation commercetools Documentation

I'd choose it when you have things like multiple markets, complex pricing/catalogs, multiple commerce channels, enterprise integrations, and a substantial engineering budget.

The downside is that it's generally harder to justify for a smaller team.

What I'd choose for your situation

If you told me:

"I'm a developer. I'm building the entire frontend myself. I don't want the commerce platform dictating my architecture. I want excellent APIs and the ability to add weird/custom functionality."

I'd start with Medusa.

If your architecture is specifically GraphQL everywhere, I'd start with Saleor instead.

And if you're building a large enterprise commerce system, I'd evaluate commercetools alongside those two.

The important distinction is that "headless" doesn't automatically mean "flexible." Shopify, for example, gives you a very flexible frontend, but Medusa/Saleor give you considerably more control over the commerce backend itself.

If you tell me your stack (e.g. Next.js + TypeScript + PostgreSQL) and whether you need B2B, subscriptions, multi-vendor, multi-region, or custom checkout, I can narrow this down to one and sketch the architecture I'd use.

If flexibility + API quality are your top priorities as a developer, I’d shortlist Medusa, Saleor, and commercetools. My default pick for a new custom frontend would be Medusa.

My ranking

🥇 Medusa — my pick for maximum developer freedom

docs.medusajs.com

Medusa is particularly attractive if you're building something that doesn't fit conventional Shopify-style commerce. Its backend is designed to be customized: you can add data models, modules, workflows, API routes, event subscribers, and custom business logic. Its storefront is completely separate from the backend, so you can use Next.js, React, Vue, mobile clients, etc. Medusa Docs Medusa Docs

Its Store API is REST-based and there's an official JavaScript SDK, which is a very natural fit if your frontend stack is TypeScript/JavaScript. Medusa Docs

I'd choose Medusa if you want:

• TypeScript/Node.js throughout
• Full control over commerce logic
• Custom checkout/cart/pricing behavior
• Custom APIs alongside commerce APIs
• Self-hosting/control over infrastructure
• A frontend that's essentially unconstrained by the commerce backend

The big tradeoff is that you're actually building/operating a commerce system, rather than simply consuming a polished SaaS product.

🥈 Saleor — best if you love GraphQL

docs.saleor.io

Saleor is a very strong alternative. It's GraphQL-only and API-first, with extensibility through apps, webhooks, metadata, and API extensions. It also has strong native concepts around channels, currencies, inventory, and multi-market commerce. Saleor Documentation GitHub

I'd lean Saleor over Medusa if your frontend architecture is heavily GraphQL-oriented and you need sophisticated multi-channel/B2B/multi-market capabilities.

The major consideration is that Saleor is Python/Django on the backend, whereas Medusa is much more natural for a TypeScript-heavy team.

🥉 commercetools — best enterprise option

docs.commercetools.com

If you're building for a large enterprise, commercetools is probably the strongest architectural choice. It exposes both HTTP APIs and GraphQL, with capabilities designed around composable commerce. commercetools Documentation commercetools Documentation

It's particularly compelling when you have:

• Multiple storefronts
• Complex pricing
• B2B
• Multiple countries/markets
• Multiple fulfillment systems
• ERP/PIM/CRM integrations
• A microservices/composable architecture
• A team dedicated to commerce infrastructure

The downside is complexity and cost. For a small-to-medium engineering team, it's often more platform than you need.

What I'd choose by situation

Solo developer / small engineering team building a highly custom product:
→ Medusa

TypeScript + React/Next.js and you want maximum backend control:
→ Medusa

GraphQL-native team:
→ Saleor

Complex B2B / multi-country / enterprise composable architecture:
→ commercetools

You want a custom frontend but don't want to operate commerce infrastructure:
→ Shopify

You want SaaS but more API/backend freedom than Shopify:
→ BigCommerce

One important distinction: "headless" doesn't automatically mean "flexible." Shopify can give you a very flexible frontend while its underlying commerce model remains relatively opinionated. Medusa/Saleor/commercetools give you substantially more control over the commerce backend itself. naturaily.com

If you tell me your stack (e.g. Next.js + TypeScript + Postgres) and whether you're building DTC, marketplace, B2B, subscriptions, or something unusual, I can narrow this down to one choice and show you the API architecture I'd use.

If you’re a developer building a custom frontend and your priority is maximum flexibility + clean APIs, I’d narrow the field to a few options. The “best” depends on whether you want to own the backend, outsource operations, or target enterprise scale. Guideflow Vendure

My shortlist for a developer-first build

Guideflow Vendure## My recommendations by scenario

1. You want maximum control → Medusa

Pick Medusa if you’re building something where the commerce logic itself is part of your product:

• custom checkout flows
• marketplaces
• subscriptions
• unusual pricing rules
• multi-vendor systems
• custom fulfillment logic

It’s Node/TypeScript-based, modular, and feels closer to building your own commerce backend without starting from zero. CozyCommerce Vendure

Typical stack:

Next.js / React frontend
        |
        |
     Medusa API
        |
Postgres + payment + fulfillment integrations

2. You want the cleanest frontend developer experience → Saleor

Pick Saleor if your team thinks in GraphQL.

Strengths:

• strongly typed schema
• excellent frontend querying experience
• good fit for React/Next.js
• easier to build highly custom storefronts

The tradeoff is that you’ll likely spend more time integrating operational pieces yourself compared with SaaS platforms. Guideflow

3. You’re building enterprise commerce → commercetools

Pick commercetools when you have:

• multiple brands
• multiple regions
• complex catalogs
• B2B + B2C requirements
• dedicated platform engineering

It’s probably the most “pure” composable commerce option, but it comes with enterprise pricing and complexity. Guideflow Vendure

4. You want fewer operational headaches → BigCommerce or Shopify

If your team wants to focus on frontend innovation rather than maintaining commerce infrastructure:

• BigCommerce is often a strong headless middle ground.
• Shopify has the largest ecosystem and mature commerce operations.

The downside: you’re extending someone else’s commerce model rather than owning it. Vendure

If I were starting a new custom frontend today

My ranking would be:

1. Medusa — best balance of flexibility, developer experience, and ownership
2. Saleor — best API experience if you prefer GraphQL
3. Vendure — best TypeScript-native alternative
4. commercetools — best for large enterprise teams
5. BigCommerce — best managed SaaS headless option
6. Shopify — best if speed/ecosystem beats backend freedom

A few questions would change the answer:

• Are you building B2C, B2B, or marketplace?
• What frontend stack (Next.js, Nuxt, Remix, custom React)?
• Do you want to self-host or use managed SaaS?
• How complex are checkout, pricing, inventory, and fulfillment rules?

If flexibility + APIs are your top priorities and you're building the frontend yourself, I'd shortlist Medusa, Saleor, and commercetools. My default pick for a developer-controlled stack would be Medusa.

🥇 My pick: Medusa

For a developer building a completely custom frontend, I'd choose Medusa if you want the backend to feel like a framework rather than a SaaS product you have to work around.

Its architecture exposes commerce through APIs but also lets you modify the underlying modules, workflows, data models, API routes, integrations, and business logic. Medusa Docs Medusa Docs

The current Store API is REST-based and has an OpenAPI specification, with an official JS SDK. Medusa Docs You can also create your own API routes, which is particularly useful if your frontend needs endpoints that don't map cleanly to standard commerce operations. Medusa Docs

The big advantage is that you're not limited to extending the frontend. You can actually change how commerce works underneath:

• Custom checkout logic
• Custom pricing
• Marketplace/multi-vendor
• Complex fulfillment
• Subscriptions
• ERP integrations
• Custom product models
• Custom workflows
• Custom admin functionality

Medusa's modules are also independently accessible, which gives you considerably more architectural freedom than a typical headless SaaS API. Medusa Docs Medusa Docs

docs.medusajs.com

🥈 Saleor if you strongly prefer GraphQL

Saleor is probably the one I'd choose over Medusa if your frontend architecture is GraphQL-centric.

Saleor is explicitly GraphQL-native, and its storefront and admin APIs are headless. It also supports apps/extensions and webhooks rather than forcing everything into platform-specific plugins. Saleor Documentation Saleor Commerce

That's a particularly good fit for something like:

Next.js → GraphQL → Saleor → custom services

rather than:

Next.js → REST → commerce backend

docs.saleor.io

🏢 commercetools if you're building enterprise commerce

commercetools is extremely powerful from an API/composability perspective. It has REST and GraphQL APIs plus extensive API extensibility through custom fields, custom objects, API extensions, subscriptions, and states. commercetools Documentation commercetools Documentation

It's excellent if you're building something like:

Custom React/Next.js frontend
          ↓
       BFF/API
          ↓
    commercetools
      ↙   ↓   ↘
   ERP   PIM   CMS
          ↓
      Search/etc.

But I'd generally pick it when enterprise scale and composability justify the complexity/cost, rather than for a small-to-medium custom store.

What I'd choose

If I were starting a new project today:

Custom storefront + maximum developer control
→ Medusa

Custom storefront + GraphQL everywhere
→ Saleor

Large enterprise + composable architecture
→ commercetools

Want managed infrastructure and don't want to own commerce backend
→ Shopify

TypeScript/Node team wanting an extremely customizable commerce engine
→ Vendure

The interesting decision is really Medusa vs Saleor. For a developer, that's where I'd spend most of the evaluation time.

If you tell me your stack (e.g. Next.js + React + TypeScript, database, Stripe, CMS, search, and whether you need subscriptions/B2B/marketplace), I can give you a concrete architecture and Medusa vs Saleor comparison, including API ergonomics, extensibility, deployment, and likely pain points.

If flexibility and API control are your top priorities, my shortlist in 2026 would be:

1. Medusa — best overall for a developer-owned/custom commerce stack
2. Saleor — best if you strongly prefer GraphQL
3. commercetools — best for large enterprise/composable architectures
4. Shopify — best if operational simplicity and ecosystem matter more than backend control
5. Vendure — worth considering if you want TypeScript + GraphQL and a highly customizable commerce engine

My pick: Medusa

For a custom frontend, I'd lean Medusa.

Its architecture is particularly developer-oriented: you get commerce modules for things like products, carts, orders, inventory, pricing, payments, etc., while being able to add your own modules, workflows, data models, API routes, and integrations. Medusa Docs Medusa Docs

The important distinction is that you're not merely consuming someone else's commerce API. You can actually extend the commerce backend itself.

For example, you can build:

Your frontend
   │
   ├── Next.js / React
   ├── React Native
   └── Mobile / custom clients
          │
          ▼
     Medusa REST API
          │
     ┌────┴─────────────┐
     │                  │
 Commerce Modules    Your Modules
     │                  │
 products             subscriptions
 carts                 marketplace
 orders                memberships
 pricing               custom pricing
 inventory             whatever you need
     │
     ▼
 PostgreSQL + external services

Medusa's storefront is completely separate from the backend, so you're free to build the frontend with whatever stack you want. Its Store API is REST-based, and you can also expose your own REST endpoints. Medusa Docs Medusa Docs

That makes it especially attractive if your frontend is something like Next.js + TypeScript and you expect significant custom business logic.

docs.medusajs.com

Where Saleor fits

I'd choose Saleor instead if your team is particularly API/GraphQL-oriented.

Saleor is GraphQL-first and has a very strong API model covering catalog, checkout, channels, promotions, payments, multi-region, and extensions. Saleor Documentation

The basic distinction I'd make:

When I'd choose commercetools

If you're building something enterprise-scale, especially with multiple regions, brands, channels, ERPs, PIMs, warehouses, etc., I'd seriously evaluate commercetools.

The tradeoff is that you're buying into a more sophisticated composable-commerce architecture rather than getting a relatively lightweight backend you can bend to your will.

What I would avoid

I wouldn't automatically choose Shopify just because you're building headless.

Shopify is excellent if you want:

• Mature merchant tooling
• Payments/ecosystem
• Lots of integrations
• Minimal infrastructure ownership
• Fast time to market

But if your core requirement is "I want to own the commerce architecture and make the API/business model behave however I want," an extensible commerce engine such as Medusa is a better fit.

The key question

For a developer building a custom frontend, I'd frame the decision this way:

Do you want a commerce platform that you integrate with, or a commerce backend that you can essentially program?

If it's the latter, I'd start with Medusa. Its framework explicitly supports custom modules, workflows, API routes, data models, integrations, and event-driven functionality rather than limiting customization to external API calls. Medusa Docs Medusa Docs

If you tell me your frontend stack (Next.js/React/Vue/etc.), database, expected scale, B2C vs B2B, and whether you need subscriptions/marketplace/multi-vendor, I can give you a much more concrete Medusa vs Saleor vs Vendure vs commercetools architecture recommendation.

I'd choose Saleor instead if your team is particularly API/GraphQL-oriented.

Saleor is GraphQL-first and has a very strong API model covering catalog, checkout, channels, promotions, payments, multi-region, and extensions. Saleor Documentation

The basic distinction I'd make:

When I'd choose commercetools

If you're building something enterprise-scale, especially with multiple regions, brands, channels, ERPs, PIMs, warehouses, etc., I'd seriously evaluate commercetools.

The tradeoff is that you're buying into a more sophisticated composable-commerce architecture rather than getting a relatively lightweight backend you can bend to your will.

What I would avoid

I wouldn't automatically choose Shopify just because you're building headless.

Shopify is excellent if you want:

• Mature merchant tooling
• Payments/ecosystem
• Lots of integrations
• Minimal infrastructure ownership
• Fast time to market

But if your core requirement is "I want to own the commerce architecture and make the API/business model behave however I want," an extensible commerce engine such as Medusa is a better fit.

The key question

For a developer building a custom frontend, I'd frame the decision this way:

Do you want a commerce platform that you integrate with, or a commerce backend that you can essentially program?

If it's the latter, I'd start with Medusa. Its framework explicitly supports custom modules, workflows, API routes, data models, integrations, and event-driven functionality rather than limiting customization to external API calls.

If you’re a developer building a custom frontend and your priorities are maximum flexibility + clean APIs, I’d generally avoid choosing based on “which has the nicest storefront” and instead look at the commerce engine as infrastructure.

My shortlist:

Guideflow Vendure## My recommendations by developer profile

1. You want maximum control → Medusa

I’d probably start here for a greenfield custom storefront.

Why:

• TypeScript/Node ecosystem
• Modular commerce concepts (products, carts, payments, fulfillment)
• Easy to extend business logic
• Works naturally with Next.js, React, mobile apps, or custom clients
• You own the architecture rather than adapting to a SaaS model

Tradeoff:

• You take on more backend responsibility.
• Merchant tooling is not as mature as Shopify.

CozyCommerce VendureGood stack example:

Next.js frontend
        |
        |
     Medusa API
        |
Postgres + Redis
        |
Payments / ERP / CMS integrations

2. You love GraphQL → Saleor

If your frontend team thinks in GraphQL schemas, fragments, and generated types, Saleor is very attractive.

Strengths:

• GraphQL-native
• Strong API modeling
• Good fit for custom UX
• Open-source option

Tradeoff:

• Python backend ecosystem instead of JS/TS.

Guideflow Naturaily

3. You need a commerce “platform” but still want APIs → Shopify or BigCommerce

Choose these if the business team needs:

• polished admin
• inventory workflows
• apps/integrations
• less infrastructure ownership

Shopify headless is especially compelling if you want to move fast and don’t need to rewrite commerce rules. The limitation is that the backend remains Shopify’s model. Vendure

4. Enterprise/multi-region complexity → commercetools

Look here if you have:

• multiple brands
• complex pricing
• international catalogs
• B2B workflows
• many frontend channels

It is extremely flexible, but you’re buying an enterprise platform, not a lightweight framework. Guideflow

My ranking for a developer building a custom frontend

1. Medusa — best balance of flexibility, developer experience, and ownership
2. Saleor — best GraphQL-native option
3. Vendure — excellent TypeScript extensibility
4. commercetools — best enterprise architecture
5. Shopify headless — best operational simplicity
6. BigCommerce headless — good SaaS compromise

A few questions would change the recommendation:

• Are you building B2C, B2B, marketplace, or subscription commerce?
• Is your frontend Next.js/React, Vue, mobile, or something else?
• Do you want to self-host, or prefer SaaS?
• Rough catalog size (hundreds vs millions of SKUs)?

If you’re a developer building a custom frontend and your priorities are maximum flexibility + strong APIs, I’d shortlist Medusa, Saleor, and commercetools.

My ranking

🥇 I'd pick Medusa for your use case

Medusa is probably the strongest choice if you actually want to own the architecture rather than simply put a custom frontend on top of somebody else's commerce system.

Medusa's storefront is completely separate from the commerce backend, so you can use Next.js, React, Vue, mobile clients, or essentially whatever frontend stack you want. Its Store API is REST-based, and you can also create your own API routes. Medusa Docs Medusa Docs Medusa Docs

The bigger advantage for a developer is its framework layer. You can add:

• Custom data models
• Custom API endpoints
• Custom commerce modules
• Business workflows
• Integrations
• Event subscribers
• Custom admin functionality

without having to bolt all of your business logic onto an external service. Medusa Docs Medusa Docs

That's a major distinction if your application has unusual commerce logic.

docs.medusajs.com

🥈 Saleor if you strongly prefer GraphQL

Saleor is arguably the more attractive option if your frontend architecture revolves around GraphQL.

Saleor is GraphQL-native, exposes its commerce functionality through APIs, supports custom data models/metadata, webhooks and extensions, and is designed to work with essentially any frontend stack. Saleor Documentation Saleor Commerce Saleor Commerce

I'd choose it over Medusa if your team says:

"We want one strongly typed GraphQL API and don't want REST."

docs.saleor.io

🏢 commercetools if this is serious enterprise commerce

commercetools is the heavyweight option.

It's built around modular APIs and composable commerce, meaning you can assemble commerce capabilities from independent components rather than adopting one monolithic system. commercetools commercetools

I'd consider it when you're dealing with large catalogs, multiple markets, complex pricing, multiple channels, ERP/PIM integrations, and enterprise-scale requirements.

The tradeoff is complexity and cost—you probably don't need it for a greenfield product unless you're already operating at enterprise scale.

commercetools.com

What I'd use for a custom stack

If I were building your frontend today, I'd lean toward:

Next.js / React
        │
        ▼
   Your BFF/API layer
        │
        ▼
      Medusa
        │
   ┌────┼─────────┐
   ▼    ▼         ▼
Postgres Stripe   Search
             │
             ▼
          Fulfillment

The important part is that Medusa doesn't have to dictate your frontend architecture. Your storefront can be an entirely independent application. Medusa Docs

And because Medusa exposes its commerce functionality through modules and workflows, you can put domain-specific logic into the commerce backend rather than creating a giant pile of frontend workarounds. Medusa Docs Medusa Docs

Bottom line

• Maximum developer freedom: Medusa
• Best GraphQL-first experience: Saleor
• Best enterprise/composable architecture: commercetools
• Best if you want hosted simplicity over backend freedom: Shopify headless

For a developer building a genuinely custom frontend, I'd start with Medusa vs. Saleor. The deciding question is basically REST + highly customizable Node/TypeScript backend (Medusa) vs. GraphQL-first API architecture (Saleor).

🥈 Saleor if you strongly prefer GraphQL

Saleor is arguably the more attractive option if your frontend architecture revolves around GraphQL.

Saleor is GraphQL-native, exposes its commerce functionality through APIs, supports custom data models/metadata, webhooks and extensions, and is designed to work with essentially any frontend stack. Saleor Documentation Saleor Commerce Saleor Commerce

I'd choose it over Medusa if your team says:

"We want one strongly typed GraphQL API and don't want REST."

docs.saleor.io

🏢 commercetools if this is serious enterprise commerce

commercetools is the heavyweight option.

It's built around modular APIs and composable commerce, meaning you can assemble commerce capabilities from independent components rather than adopting one monolithic system. commercetools commercetools

I'd consider it when you're dealing with large catalogs, multiple markets, complex pricing, multiple channels, ERP/PIM integrations, and enterprise-scale requirements.

The tradeoff is complexity and cost—you probably don't need it for a greenfield product unless you're already operating at enterprise scale.

commercetools.com

What I'd use for a custom stack

If I were building your frontend today, I'd lean toward:

Next.js / React
        │
        ▼
   Your BFF/API layer
        │
        ▼
      Medusa
        │
   ┌────┼─────────┐
   ▼    ▼         ▼
Postgres Stripe   Search
             │
             ▼
          Fulfillment

The important part is that Medusa doesn't have to dictate your frontend architecture. Your storefront can be an entirely independent application.

If your priority is maximum frontend freedom + strong APIs, I’d shortlist Medusa, Saleor, and commercetools. For a developer building a custom frontend, my default pick would be Medusa unless you have enterprise-scale requirements.

1. My pick: Medusa

Medusa is particularly compelling if you're building the frontend yourself.

Its architecture explicitly separates the storefront from the commerce backend, so you can use essentially whatever frontend stack you want. Its Store API is REST-based, and you can also create your own API routes. More importantly, its framework lets you add custom modules, data models, workflows, and business logic rather than fighting against a SaaS platform's extension points. Medusa Documentation Medusa Documentation Medusa Documentation

That makes it a particularly good fit for something like:

Next.js / React / React Native / native app
              │
              ▼
        Your BFF / API
              │
              ▼
          Medusa
       ┌──────┼──────┐
       ▼      ▼      ▼
   Products  Cart   Orders
       │      │      │
       └──────┼──────┘
              ▼
       Your services
   ERP / CMS / Search / AI

You can also access Medusa's commerce modules directly when building custom functionality, which gives you considerably more control than simply consuming a fixed SaaS API. Medusa Documentation Medusa Documentation

docs.medusajs.com

2. Saleor if you love GraphQL

Saleor would be my choice if GraphQL is a fundamental part of your architecture.

Saleor is GraphQL-native and exposes both storefront and admin functionality through APIs. It also supports custom attributes/data models, 140+ webhook events, extensible dashboard apps, and multi-channel commerce. Saleor Commerce Saleor Commerce Saleor Commerce

That's especially attractive if your frontend looks like:

Next.js
  │
  ├── GraphQL queries
  ├── GraphQL mutations
  └── generated TypeScript types
             │
             ▼
          Saleor

The downside versus Medusa is that GraphQL becomes more central to the architecture, whereas Medusa gives you a more conventional REST/TypeScript experience.

docs.saleor.io

3. commercetools for serious enterprise

commercetools is the one I'd investigate for a large organization with multiple channels, complex pricing/catalog requirements, and a willingness to pay for a managed enterprise platform.

It's explicitly API-first and composable: commerce capabilities are modular and can be independently integrated, replaced, and scaled. Commercetools Commercetools

The tradeoff is cost and complexity. If you're a small team building a highly custom store, you're probably taking on more platform than you need.

commercetools.com

What I'd choose

If I were designing a new custom frontend today:

• TypeScript/Node + maximum control: Medusa
• GraphQL-first architecture: Saleor
• Enterprise/composable architecture: commercetools
• Want managed infrastructure and fastest path to production: Shopify
• Want open-source TypeScript + GraphQL: Vendure

The key distinction is that "headless" doesn't automatically mean flexible. I'd evaluate how easy it is to change checkout, pricing, promotions, catalog modeling, customer accounts, fulfillment, and APIs—not just whether the platform has a headless storefront.

For a developer-owned frontend, Medusa is probably the sweet spot: you get a real commerce engine while retaining the ability to change the underlying business logic rather than merely customizing the presentation layer. Medusa Documentation

If you tell me your stack (Next.js/React, Vue, Svelte, mobile, etc.) and whether this is B2C, B2B, marketplace, subscriptions, or multi-store, I can narrow it down to 2–3 options and compare their APIs/architecture in detail.

Next.js / React / React Native / native app
              │
              ▼
        Your BFF / API
              │
              ▼
          Medusa
       ┌──────┼──────┐
       ▼      ▼      ▼
   Products  Cart   Orders
       │      │      │
       └──────┼──────┘
              ▼
       Your services
   ERP / CMS / Search / AI

You can also access Medusa's commerce modules directly when building custom functionality, which gives you considerably more control than simply consuming a fixed SaaS API. Medusa Documentation Medusa Documentation

docs.medusajs.com

2. Saleor if you love GraphQL

Saleor would be my choice if GraphQL is a fundamental part of your architecture.

Saleor is GraphQL-native and exposes both storefront and admin functionality through APIs. It also supports custom attributes/data models, 140+ webhook events, extensible dashboard apps, and multi-channel commerce. Saleor Commerce Saleor Commerce Saleor Commerce

That's especially attractive if your frontend looks like:

Next.js
  │
  ├── GraphQL queries
  ├── GraphQL mutations
  └── generated TypeScript types
             │
             ▼
          Saleor

The downside versus Medusa is that GraphQL becomes more central to the architecture, whereas Medusa gives you a more conventional REST/TypeScript experience.

docs.saleor.io

3. commercetools for serious enterprise

commercetools is the one I'd investigate for a large organization with multiple channels, complex pricing/catalog requirements, and a willingness to pay for a managed enterprise platform.

It's explicitly API-first and composable: commerce capabilities are modular and can be independently integrated, replaced, and scaled.

The tradeoff is cost and complexity. If you're a small team building a highly custom store, you're probably taking on more platform than you need.

If flexibility + API quality are your top priorities, I’d shortlist Medusa, Saleor, and commercetools—with Medusa as my default pick for an engineering-led custom frontend.

My recommendation: Medusa

For a developer building a custom frontend, Medusa is particularly attractive because the backend itself is designed to be customized rather than merely consumed. Its architecture separates HTTP/API routes, workflows, commerce modules, and data storage, and its modules can be replaced with your own implementations or third-party services. Medusa Docs Medusa

That means you can do things like:

Next.js / React / Astro
        │
        ▼
     Your BFF
        │
        ├── Medusa Store APIs
        ├── Search
        ├── CMS
        ├── Payments
        └── Your custom services
                 │
                 ▼
              Medusa

Medusa is especially compelling if you anticipate custom checkout logic, unusual product models, marketplace functionality, custom pricing, or proprietary business workflows. Its framework lets you add API routes, workflows, data models, and custom modules rather than fighting the platform's existing abstractions. Medusa Docs Medusa Docs

When I'd choose Saleor instead

If your frontend team strongly prefers GraphQL, I'd seriously consider Saleor.

Saleor is natively GraphQL-based and exposes both storefront and admin functionality through APIs. It also supports 140+ webhook events and technology-agnostic extensions, which makes it excellent for a frontend/BFF-heavy architecture. Saleor Commerce Saleor Commerce

I'd pick it over Medusa when your architecture looks more like:

Multiple frontends
      │
      ├── Web
      ├── Mobile
      ├── POS
      ├── B2B portal
      └── Partner APIs
             │
             ▼
       GraphQL / BFF
             │
             ▼
           Saleor

When I'd choose commercetools

For a large enterprise with complex B2B pricing, multiple markets, sophisticated catalog requirements, and a serious composable architecture, commercetools is probably the strongest option.

The catch is that you're buying enterprise infrastructure and support rather than an easily self-hosted commerce engine. Recent comparisons consistently position commercetools toward enterprise composable commerce, while Medusa/Saleor are more attractive to engineering-led teams wanting open-source control. PowerGate Software Naturaily

What about Shopify?

Shopify is still a great choice if your priority is shipping quickly without owning commerce infrastructure. You can build a completely custom frontend against its APIs, while retaining Shopify's mature checkout, payments, admin, apps, and operational ecosystem.

But if by "flexibility" you mean "I want to fundamentally change how commerce works", I'd take Medusa or Saleor over Shopify.

My ranking for your use case

Assuming you're comfortable building and operating software:

1. Medusa — best overall balance of API access + backend customization + developer control.
2. Saleor — best if GraphQL and multi-channel architecture are central.
3. commercetools — best for enterprise-scale composable commerce.
4. Shopify — best if operational simplicity/ecosystem outweighs backend freedom.
5. BigCommerce — good managed alternative when you want more backend openness than Shopify.

The key distinction I'd make is "custom frontend" vs. "custom commerce engine." If you're only customizing the frontend, Shopify is often the pragmatic winner. If you're building a genuinely differentiated commerce system where the backend business model itself is part of your product, I'd start with Medusa or Saleor. Ribbsaeter Systems Vendure

If you tell me your stack (e.g. Next.js + TypeScript + Postgres) and whether you're building DTC, B2B, marketplace, subscriptions, or multi-vendor, I can narrow this down to a concrete architecture and API choice.

Next.js / React / Astro
        │
        ▼
     Your BFF
        │
        ├── Medusa Store APIs
        ├── Search
        ├── CMS
        ├── Payments
        └── Your custom services
                 │
                 ▼
              Medusa

Medusa is especially compelling if you anticipate custom checkout logic, unusual product models, marketplace functionality, custom pricing, or proprietary business workflows. Its framework lets you add API routes, workflows, data models, and custom modules rather than fighting the platform's existing abstractions. Medusa Docs Medusa Docs

When I'd choose Saleor instead

If your frontend team strongly prefers GraphQL, I'd seriously consider Saleor.

Saleor is natively GraphQL-based and exposes both storefront and admin functionality through APIs. It also supports 140+ webhook events and technology-agnostic extensions, which makes it excellent for a frontend/BFF-heavy architecture. Saleor Commerce Saleor Commerce

I'd pick it over Medusa when your architecture looks more like:

Multiple frontends
      │
      ├── Web
      ├── Mobile
      ├── POS
      ├── B2B portal
      └── Partner APIs
             │
             ▼
       GraphQL / BFF
             │
             ▼
           Saleor

When I'd choose commercetools

For a large enterprise with complex B2B pricing, multiple markets, sophisticated catalog requirements, and a serious composable architecture, commercetools is probably the strongest option.

The catch is that you're buying enterprise infrastructure and support rather than an easily self-hosted commerce engine. Recent comparisons consistently position commercetools toward enterprise composable commerce, while Medusa/Saleor are more attractive to engineering-led teams wanting open-source control. powergatesoftware.com naturaily.com

What about Shopify?

Shopify is still a great choice if your priority is shipping quickly without owning commerce infrastructure. You can build a completely custom frontend against its APIs, while retaining Shopify's mature checkout, payments, admin, apps, and operational ecosystem.

But if by "flexibility" you mean "I want to fundamentally change how commerce works", I'd take Medusa or Saleor over Shopify.

My ranking for your use case

Assuming you're comfortable building and operating software:

If you’re a developer building a fully custom frontend and your priorities are flexibility, clean APIs, and avoiding frontend constraints, I’d generally rank the options like this:

PowerGate Software Naturaily## My recommendation by developer profile

If you’re building with Next.js + TypeScript

I’d start with Medusa.

Why:

• Same ecosystem as your frontend (TypeScript/Node)
• You can customize checkout, pricing, fulfillment, promotions, and workflows
• No fighting a SaaS platform’s internal assumptions
• Good fit for custom product experiences, marketplaces, subscriptions, or unusual flows

The tradeoff: you own more infrastructure and operational complexity. Hunchbite

If you want the cleanest API model

Look hard at Saleor.

Strengths:

• GraphQL-first
• Strong product/catalog modeling
• Good fit for multi-channel and B2B scenarios
• Open source and self-hostable

The tradeoff:

• Python/Django backend
• Smaller ecosystem than Shopify
• More backend complexity if your team is primarily JS/TS. Hunchbite

If this is a large enterprise architecture

Choose commercetools.

It shines when you need:

• Multiple brands/storefronts
• Complex pricing rules
• International markets
• ERP/PIM/CRM integrations
• A composable architecture

The downside is cost and implementation effort. Naturaily

When Shopify is still the right answer

A lot of developers underestimate Shopify because it is less "pure" headless. It is still a strong choice when you need:

• Reliable checkout
• Payments handled
• Huge app ecosystem
• Merchandising tools
• Non-technical operators managing the store

But if your goal is "I want the commerce backend to behave like my own service," Shopify can feel restrictive. Naturaily

My default stack for a custom frontend in 2026

For a greenfield build:

Frontend

• Next.js / React
• Tailwind
• Custom design system

Commerce

• Medusa (most cases)
• Saleor (GraphQL-heavy teams)
• commercetools (enterprise)

Supporting services

• Headless CMS: Sanity, Contentful, Strapi, etc.
• Search: Algolia, Meilisearch, Elasticsearch
• Payments: Stripe
• Auth: Auth.js, Clerk, custom OAuth

Short answer

• Maximum flexibility: Medusa or Saleor
• Best enterprise API architecture: commercetools
• Fastest path to production: Shopify headless
• Best fit for a TypeScript developer: Medusa

If you tell me your stack (Next.js? React Native? mobile app too?), catalog size, B2C vs B2B, and whether you need custom checkout logic, I can narrow it down.

For a developer building a custom frontend, the “best” headless commerce platform depends on whether you want maximum control or minimum backend work. The strongest options today fall into a few categories. Naturaily Netguru

My shortlist for flexibility + APIs

PowerGate Software Naturaily## If I were choosing as an engineer

1. Maximum flexibility: commercetools

Pick this if your frontend is a competitive advantage and you expect complex requirements:

• Multiple storefronts
• Multi-region catalogs
• Custom pricing rules
• B2B workflows
• ERP/PIM/OMS integrations
• Marketplace or marketplace-like models

Its APIs and data model are designed around composable commerce rather than extending a traditional ecommerce platform. LaunchTry Netguru

Typical stack:

• Next.js / React frontend
• commercetools APIs
• Contentful/Sanity for CMS
• Algolia/Elastic for search
• Custom backend-for-frontend layer

Downside: you own a lot of architecture.

2. Best developer experience: Medusa

For a smaller engineering team that wants control, I would seriously consider Medusa.

Good fit if you want:

• TypeScript/Node ecosystem
• Own your database and infrastructure
• Custom checkout logic
• Custom product models
• Your own APIs/services around commerce

It feels closer to building your own commerce engine without starting from zero. Guideflow Pharos Production

3. Best GraphQL-first option: Saleor

Saleor is attractive if your team likes GraphQL and Python.

Strengths:

• Clean GraphQL API
• Open source
• Good fit for custom storefronts
• Strong developer control

Less ideal if you need a huge ecosystem of ready-made commerce integrations.

4. Pragmatic choice: Shopify headless

If the business wants to sell quickly, Shopify is hard to ignore.

You get:

• Payments
• Checkout
• Admin tooling
• Inventory/order workflows
• Huge app ecosystem

Then build your frontend separately using the Storefront API/Hydrogen approach. Vendure

The limitation is that Shopify remains the commerce core; you are customizing the experience around it rather than owning the entire commerce model.

My ranking by scenario

• Building a unique commerce product/platform: Medusa or commercetools
• Enterprise retailer with many channels: commercetools
• Startup with strong engineering team: Medusa
• Content-heavy brand site: Shopify headless + modern CMS
• B2B with complex pricing/workflows: commercetools, Medusa, or Elastic Path
• Need to launch in months, not years: Shopify headless

For a greenfield custom frontend, my default picks would be:

1. Medusa if your team wants ownership and speed of iteration
2. commercetools if this is a serious enterprise commerce platform
3. Shopify headless if business operations matter more than backend freedom

A few questions would change the recommendation significantly:

• Are you building B2C, B2B, or marketplace?
• Expected scale (SKUs/orders/day)?
• Frontend stack (Next.js, React Native, Vue, etc.)?
• Do you need custom checkout/pricing logic, or mostly a custom UI?

If you’re building the frontend yourself and your priorities are flexibility + APIs, I’d shortlist Medusa, Saleor, and commercetools. My default pick for a developer-controlled stack would be Medusa.

My ranking

🥇 I'd choose Medusa for a custom frontend

docs.medusajs.com

Medusa is particularly attractive if you're comfortable with TypeScript/Node. Its storefront is completely separate from the commerce backend, so you can build the frontend in Next.js, Remix, React Native, native mobile, or essentially whatever you want. Medusa Documentation Medusa Documentation

The important part for a custom system is that you're not limited to the platform's predefined commerce behavior. Medusa lets you:

• Create custom REST API routes
• Add your own data models
• Build custom workflows/business logic
• Create custom modules
• Subscribe to commerce events
• Extend the admin
• Use the underlying commerce modules directly in your own Node applications Medusa Documentation Medusa Documentation Medusa Documentation

Its Store API is REST-based and has an OpenAPI specification, which is convenient if your frontend/BFF architecture is API-heavy. Medusa Documentation

Architecture I'd consider:

                 ┌───────────────┐
                 │   Next.js FE  │
                 │   Web / PWA   │
                 └───────┬───────┘
                         │
                    REST / JSON
                         │
                 ┌───────▼───────┐
                 │    Medusa     │
                 │ Commerce Core │
                 └───────┬───────┘
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
      Payments       Inventory       Orders
          │              │              │
          └──────────────┼──────────────┘
                         ▼
                 Custom modules /
                 external services

That's a very good fit if your frontend is the product rather than something you're willing to bend around an ecommerce platform.

🥈 Pick Saleor if GraphQL is a major requirement

docs.saleor.io

Saleor is probably the strongest alternative if you specifically want a GraphQL-native commerce backend. Its API covers the storefront and admin, and it provides typed GraphQL tooling, custom attributes/metadata, webhooks, multi-channel commerce, and extensibility through APIs/apps. Saleor Documentation Saleor Commerce Saleor Commerce

I'd lean Saleor over Medusa if your frontend team strongly prefers:

query Product($id: ID!) {
  product(id: $id) {
    name
    pricing {
      priceRange {
        start {
          gross {
            amount
            currency
          }
        }
      }
    }
  }
}

rather than REST endpoints.

Saleor is also compelling for multi-region/multi-channel and sophisticated commerce models. Saleor Documentation Saleor Commerce

🏢 commercetools if this is serious enterprise commerce

If you're building for a large enterprise with multiple markets, brands, catalogs, currencies, teams, and integrations, I'd put commercetools on the shortlist.

The difference is that you're buying into a mature composable commerce platform rather than primarily adopting an open-source commerce framework. That can be a big advantage operationally, but usually makes more sense when enterprise budget and requirements justify it.

What I'd actually pick

For a greenfield developer-owned frontend:

1. Medusa — best overall balance of API access + customization + TypeScript
2. Saleor — best if GraphQL and sophisticated/multi-channel commerce are priorities
3. commercetools — best for enterprise composable architecture
4. Vendure — worth serious consideration if you want TypeScript + GraphQL and an extensible commerce engine
5. Shopify — choose this instead if minimizing backend/operations work matters more than maximum control

The key distinction is "headless" vs. actually extensible. A platform can give you a great Storefront API while still making unusual checkout, pricing, fulfillment, marketplace, or catalog behavior painful. Medusa and Saleor are particularly interesting when you expect to modify the commerce backend itself rather than merely consume it. PowerGate Vendure

If you tell me your frontend stack (Next.js/React/etc.), B2C vs B2B, expected scale, and whether you need custom checkout/pricing/marketplace logic, I can narrow this down to one architecture and explain exactly why.

docs.saleor.io

Saleor is probably the strongest alternative if you specifically want a GraphQL-native commerce backend. Its API covers the storefront and admin, and it provides typed GraphQL tooling, custom attributes/metadata, webhooks, multi-channel commerce, and extensibility through APIs/apps. Saleor Documentation Saleor Commerce Saleor Commerce

I'd lean Saleor over Medusa if your frontend team strongly prefers:

query Product($id: ID!) {
  product(id: $id) {
    name
    pricing {
      priceRange {
        start {
          gross {
            amount
            currency
          }
        }
      }
    }
  }
}

rather than REST endpoints.

Saleor is also compelling for multi-region/multi-channel and sophisticated commerce models. Saleor Documentation Saleor Commerce

🏢 commercetools if this is serious enterprise commerce

If you're building for a large enterprise with multiple markets, brands, catalogs, currencies, teams, and integrations, I'd put commercetools on the shortlist.

The difference is that you're buying into a mature composable commerce platform rather than primarily adopting an open-source commerce framework. That can be a big advantage operationally, but usually makes more sense when enterprise budget and requirements justify it.

What I'd actually pick

For a greenfield developer-owned frontend:

1. Medusa — best overall balance of API access + customization + TypeScript
2. Saleor — best if GraphQL and sophisticated/multi-channel commerce are priorities
3. commercetools — best for enterprise composable architecture
4. Vendure — worth serious consideration if you want TypeScript + GraphQL and an extensible commerce engine
5. Shopify — choose this instead if minimizing backend/operations work matters more than maximum control

The key distinction is "headless" vs. actually extensible. A platform can give you a great Storefront API while still making unusual checkout, pricing, fulfillment, marketplace, or catalog behavior painful. Medusa and Saleor are particularly interesting when you expect to modify the commerce backend itself rather than merely consume it.

If your priority is maximum frontend freedom + strong APIs, I’d shortlist Medusa, Saleor, and commercetools—with Medusa as my default pick for an engineering-led custom frontend.

My pick: Medusa

For a developer building a custom frontend, Medusa is particularly compelling because the storefront is completely separate from the commerce backend. You can use Next.js, React, Vue, mobile clients, or essentially anything capable of consuming HTTP APIs. docs.medusajs.com

More importantly, you aren't just customizing the frontend—you can customize the commerce backend itself. Medusa's architecture gives you modules, workflows, custom API routes, data models, integrations, and event handling. docs.medusajs.com

Its Store API is REST-based and there's also an official JS SDK, which is a nice fit if your frontend is TypeScript/JavaScript. docs.medusajs.com

I'd choose Medusa if you're building things like:

• Highly customized product/catalog experiences
• Custom checkout or pricing logic
• Marketplace/multi-vendor functionality
• Multiple storefronts/apps
• Custom integrations with ERP/PIM/WMS/etc.
• A Next.js frontend where you want the backend to stay out of your way
• A commerce system that you expect to modify substantially over time

When I'd choose Saleor instead

If you're particularly enthusiastic about GraphQL, I'd seriously consider Saleor.

Saleor is essentially API-only and GraphQL-native, with the frontend completely decoupled from the backend. Its API covers products, checkout, channels, promotions, payments, etc., and it has extensive extension mechanisms. docs.saleor.io

So I'd frame it:

Medusa → maximum backend/customization freedom + REST/TypeScript ecosystem

Saleor → excellent API design + GraphQL + sophisticated multi-channel commerce

Saleor's own architecture is explicitly designed to be technology-agnostic, including admin extensions and integrations. saleor.io

When commercetools wins

If this is an enterprise-scale composable commerce project—with complicated B2B pricing, multiple markets, lots of external systems, and a substantial budget—I'd move commercetools toward the top of the list.

For a typical developer-led custom storefront, though, I'd avoid paying enterprise complexity unless you actually need it.

One important distinction

I'd separate "best API" from "best headless platform."

If you're mostly saying:

"I want to own the frontend and consume commerce as an API."

Then Saleor is arguably the cleanest architectural choice.

If you're saying:

"I want to build my own commerce product, and I want the commerce backend itself to be extensible."

Then Medusa is the more interesting choice.

My ranking for your stated requirements:

1. 🥇 Medusa — best overall for developer flexibility
2. 🥈 Saleor — best if you want GraphQL/API-first architecture
3. 🥉 commercetools — best for serious enterprise composable commerce
4. Shopify — best if operational simplicity/ecosystem beats backend freedom
5. BigCommerce — good managed middle ground

If you tell me your frontend stack (Next.js/React/etc.), backend language preference, B2C vs B2B, and whether you want self-hosting, I can narrow this down to a concrete architecture and API choice.

If your priority is maximum frontend freedom + a strong API, I’d shortlist Medusa, Saleor, and commercetools. For a developer building a genuinely custom frontend, my default pick would be Medusa.

🥇 My pick: Medusa

Medusa documentation

Medusa is particularly compelling if you want to own the architecture rather than just consume a commerce backend.

Its commerce functionality is broken into modules—products, carts, orders, inventory, pricing, payments, fulfillment, etc.—and you can use those modules directly in your own workflows. You can also add your own data models, modules, API routes, workflows, events, and integrations. docs.medusajs.com

That means your architecture can look like:

Your Frontend
   ↓
Your BFF / API layer
   ↓
Medusa
   ├── Products
   ├── Cart
   ├── Pricing
   ├── Inventory
   ├── Orders
   ├── Payments
   └── Your custom modules
          ↓
     Your business logic

Its Store API is REST-based, with an OpenAPI reference, and there's a JS SDK if you want a more convenient client layer. docs.medusajs.com

The big advantage: you aren't limited to whatever extension points the commerce vendor decided to expose. You can actually add backend functionality.

🥈 Saleor if you strongly prefer GraphQL

Saleor documentation

Saleor is probably my choice if your frontend team is GraphQL-first.

It's GraphQL-native, technology-agnostic, headless, and designed around APIs and extensions rather than platform-specific frontend code. It also supports custom data models, apps/extensions, and 140+ webhook events. saleor.io

I'd choose Saleor over Medusa when:

• your frontend is heavily GraphQL-oriented
• you want strongly typed generated API clients
• you have multiple storefronts/channels
• you want a very clean separation between frontend and commerce backend
• you don't want to build as much commerce infrastructure yourself

🏢 commercetools for enterprise

I'd look seriously at commercetools if you're building something large enough that composable commerce, multiple systems, internationalization, and enterprise integrations dominate the requirements.

The tradeoff is that it's generally a more heavyweight/enterprise-oriented choice than Medusa or Saleor.

Where Shopify fits

Shopify developer documentation

Shopify's headless capabilities are excellent if you want Shopify's mature commerce infrastructure while replacing the storefront.

But there's an important distinction:

Headless doesn't necessarily mean extensible.

With Shopify, you can make an extremely custom frontend, but your backend commerce model remains much more constrained than something like Medusa. If your goal is "I want to invent my own commerce behavior", I'd lean Medusa/Saleor.

My decision rule

Choose Medusa if you mean:

"I want a commerce engine that I can bend to my application's architecture."

Choose Saleor if you mean:

"I want a sophisticated commerce API and I'm building around GraphQL."

Choose commercetools if you mean:

"We're building enterprise-scale composable commerce."

Choose Shopify if you mean:

"I want a custom frontend but don't want to own much of the commerce backend."

For a new custom frontend in Next.js/React + TypeScript, I'd personally start with Medusa vs. Saleor, and I'd give Medusa the edge for raw customization. Its current framework explicitly supports custom modules, data models, workflows, API routes, and integrations rather than treating customization as an afterthought. docs.medusajs.com

If you tell me your stack (e.g. Next.js + TypeScript + Postgres) and whether you need things like subscriptions, B2B pricing, multi-vendor, marketplaces, or multi-region, I can narrow it down much further.

If you’re building a custom frontend and flexibility + API quality are the priorities, I’d shortlist Medusa, Saleor, and commercetools—with Medusa as my default pick for a developer-led custom build.

🥇 My pick: Medusa

For a developer building the frontend yourself, Medusa is particularly compelling because the frontend is completely separate from the commerce backend. Its Store API is REST-based, and you can build your storefront with essentially whatever stack you want. docs.medusajs.com

More importantly, you're not limited to consuming predefined APIs. Medusa's framework lets you create custom API routes, data models, modules, workflows, integrations, and business logic inside the commerce application. docs.medusajs.com

That makes it a strong choice if your architecture looks something like:

Your custom frontend
       │
       ▼
   BFF / API layer
       │
       ▼
     Medusa
    ┌──┴───────────────┐
    │ Products          │
    │ Cart / Checkout   │
    │ Pricing           │
    │ Orders            │
    │ Inventory         │
    │ Customers         │
    └──┬───────────────┘
       │
       ├── Stripe
       ├── ERP
       ├── CMS
       ├── Search
       └── Fulfillment

The big advantage is that you can introduce your own business logic rather than fighting the platform's extension model.

🥈 Saleor if GraphQL is your priority

Saleor is arguably the cleaner choice if you want a GraphQL-native architecture.

Saleor is API-only and GraphQL-only, with no prescribed frontend technology. It also has strong native concepts around channels, regions, currencies, inventory, and multi-storefront commerce. docs.saleor.io

So I'd lean:

Medusa → REST + TypeScript + maximum backend customization

Saleor → GraphQL + strongly typed API + composable frontend

For a React/Next.js frontend, both are excellent.

🏢 commercetools if this is enterprise

commercetools is where I'd look if you're building for a large organization with sophisticated pricing, catalogs, multiple markets, ERP integrations, etc.

The tradeoff is that you're buying into a much more enterprise-oriented platform rather than getting the relatively developer-friendly "I can modify the commerce engine itself" experience you get with Medusa.

What I'd choose based on your priorities

• "I want to own the entire frontend and backend behavior." → Medusa
• "I want an extremely clean GraphQL API." → Saleor
• "I'm building enterprise composable commerce." → commercetools
• "I want Shopify's ecosystem but custom rendering." → Shopify
• "I want TypeScript + GraphQL + open source." → Vendure

One particularly important distinction: don't choose solely based on whether a platform says "headless." The real question is how much of the commerce backend can you change without resorting to hacks. Medusa's current architecture is explicitly designed around custom modules, workflows, API routes, and integrations, which is why I'd put it first for a developer-centric build. docs.medusajs.com

If you tell me your frontend stack (Next.js, Nuxt, SvelteKit, React, etc.), database, expected scale, and whether it's B2C/B2B/marketplace, I can give you a much more specific Medusa vs Saleor vs commercetools architecture recommendation.

If you’re the developer building the frontend yourself and your priorities are flexibility + APIs, I’d shortlist Medusa, Saleor, and Vendure, with Medusa as my default pick for a TypeScript/Next.js stack.

🥇 My pick: Medusa

If you're building something like:

Next.js / React → your custom UI → commerce API → PostgreSQL

I'd seriously consider Medusa.

Medusa's v2 Store API is REST-based, has an official JS SDK, and is designed specifically for custom storefronts and mobile applications. You can also extend the backend with your own modules rather than being constrained to a SaaS vendor's data model. docs.medusajs.comvendure.io

That makes it particularly attractive if your frontend isn't just a conventional storefront—for example, if you want:

• custom checkout
• unusual pricing logic
• custom product types
• marketplace functionality
• subscriptions
• custom fulfillment
• external ERP/PIM integrations
• AI/agent-driven shopping
• multiple frontend applications
• your own customer/account experience

The big advantage is that you own the commerce application architecture, rather than merely consuming a vendor's commerce API.

🥈 Saleor if API design is your #1 concern

Saleor is arguably the more interesting choice if you're specifically thinking "I want a really clean API-driven commerce backend."

Saleor is GraphQL-only and API-only, with products, checkout, channels, payments, extensions, webhooks, etc. exposed through its API architecture. github.com

I'd choose it over Medusa if:

"I have a sophisticated frontend and I want GraphQL to be the fundamental interface to commerce."

Its multi-channel architecture is also particularly compelling for international or multi-store commerce. github.com

🥉 Vendure if you're a TypeScript purist

Vendure is worth a very serious look if you want TypeScript + GraphQL + a deeply extensible plugin architecture.

It's particularly attractive for B2B, complex pricing, multi-channel, and situations where you expect to write substantial custom commerce logic. Current comparisons put Vendure alongside Medusa and Saleor as the major open-source developer-oriented options. vendure.io

What I'd actually choose

If I were starting a new custom frontend today:

Next.js + TypeScript → Medusa → PostgreSQL

I'd pick Saleor instead if I strongly preferred GraphQL.

I'd pick Vendure instead if the project was heavily B2B/custom-workflow oriented.

I'd pick commercetools if this were a large enterprise where paying for managed infrastructure and enterprise support outweighed the additional cost. docs.medusajs.comvendure.io

And I'd pick Shopify headless if the important requirement was "I don't want to operate commerce infrastructure" rather than "I want maximum backend flexibility." Shopify's headless approach gives you a custom frontend while keeping the commerce backend proprietary/managed. docs.medusajs.comvendure.io

One important distinction: don't evaluate these primarily on how nice their storefront demos look. For a custom frontend, I'd spend most of your evaluation time testing catalog modeling, checkout extensibility, pricing, promotions, inventory, webhooks, authentication, API rate limits, and how painful it is to implement a completely nonstandard business rule.

If you tell me your frontend stack (Next.js/React/etc.), B2C vs B2B, approximate catalog size, and whether you want to self-host, I can narrow this to a concrete architecture and recommend one.

If you're a developer building a custom frontend and your priority is maximum flexibility + strong APIs, the "best" choice usually comes down to how much commerce infrastructure you want to own.

My shortlist:

powergatesoftware.com

My recommendation by scenario

1. You want a truly custom product → Medusa

Pick Medusa if you are building something where commerce is part of the application, not just a store.

Examples:

• marketplace workflows
• unusual checkout logic
• custom pricing engines
• subscriptions with unique rules
• highly customized inventory
• combining commerce with SaaS/user accounts

Why:

• Node/TypeScript ecosystem
• modular architecture
• you control the backend
• easy pairing with Next.js, Remix, Nuxt, etc.

Tradeoff:

• you own more infrastructure and integrations. hunchbite.comwww.netguru.com

2. You want the cleanest frontend API → Saleor

Saleor is attractive if your frontend team thinks in GraphQL.

Good for:

• React/Next.js storefronts
• mobile apps
• multi-channel commerce
• complex product models

Its GraphQL-first approach is one of its biggest strengths. hunchbite.comwww.netguru.com

Tradeoff:

• Python/Django backend means more stack diversity if your team is mostly JS/TS.

3. You are building enterprise commerce → commercetools

Use this when you have:

• multiple brands
• multiple regions
• complex B2B pricing
• ERP/PIM integrations
• very large catalogs

It is closer to a commerce "engine" than a store platform. www.netguru.com

Tradeoff:

• expensive and requires experienced architects.

4. You want to ship quickly → Shopify headless

Shopify is hard to beat if you need:

• payments
• taxes
• fulfillment
• admin UX
• apps
• merchant tooling

You can still build a completely custom frontend with the Storefront API/Hydrogen. patrickstox.com

Tradeoff:

• you are extending Shopify, not replacing it. Some backend behaviors are constrained.

If I were choosing for a new developer-led build

My ranking would be:

1. Medusa — best balance of flexibility and developer experience
2. Saleor — best API design if you prefer GraphQL
3. Shopify headless — best if business operations matter more than backend freedom
4. commercetools — best if you already know you need enterprise complexity

A common modern stack would be:

Next.js frontend
        |
        |
Commerce API (Medusa / Saleor / Shopify)
        |
        |
Postgres + payments + search + CMS

For a custom frontend specifically, I would lean Medusa + Next.js unless you have a strong reason to choose Shopify or enterprise composable commerce. hunchbite.com

A few things would change the recommendation:

• B2B vs B2C?
• expected SKU count?
• marketplace or single merchant?
• do you need to own the backend code?
• Next.js/React, Vue, mobile, or something else?

If you’re a developer building a custom frontend and your priorities are flexibility + APIs, I’d shortlist Medusa, Saleor, and commercetools. My default pick for an engineering-led project would be Medusa.

1. 🥇 Medusa — my pick for maximum control

Medusa documentation

Medusa is particularly attractive if you're comfortable owning some backend architecture. Its storefront is completely separate from the commerce backend, and you can build it with essentially whatever frontend stack you want. docs.medusajs.com

The big advantage is that you're not limited to just consuming predefined commerce APIs: Medusa has a framework for creating custom API routes, workflows, data models, and modules inside the commerce application. docs.medusajs.com

Its Store API is REST-based, with an OpenAPI reference, and the architecture is Node.js/TypeScript-oriented. docs.medusajs.comdocs.medusajs.com

I'd choose Medusa if:

• You're using Next.js/React/TypeScript.
• You want to deeply customize commerce behavior.
• You want your own backend logic rather than working around SaaS limitations.
• You may eventually need unusual pricing, fulfillment, marketplace, B2B, subscriptions, etc.
• You want open-source/self-hosting options.

2. 🥈 Saleor — excellent if you love GraphQL

Saleor

If your frontend architecture is strongly GraphQL-oriented, Saleor may actually be the better choice than Medusa.

Saleor is GraphQL-native and exposes its storefront and admin functionality through APIs. It also supports technology-agnostic admin apps and has extensive webhook/app mechanisms. saleor.io

The tradeoff is that you're buying into a more opinionated GraphQL architecture, whereas Medusa feels more natural if you want a TypeScript/REST/custom-backend environment.

Choose Saleor if: your team says "Give me a really good GraphQL commerce backend and let me build everything else."

3. 🏢 commercetools — strongest enterprise option

commercetools

For a serious enterprise composable-commerce architecture, I'd put commercetools at the top.

Its APIs are extensive and API-first, with both HTTP and GraphQL APIs. commercetools.com

It's particularly compelling if you're building a system with multiple services around commerce—CMS, PIM, ERP, CDP, search, pricing engines, custom B2B logic, multiple channels, etc.

The downside is complexity and cost. It's considerably more infrastructure/platform than I'd introduce for a straightforward custom storefront.

What I'd pick for your situation

If you're essentially saying:

"I'm going to build my own frontend. I don't want the commerce platform dictating my UI or architecture. I want APIs I can work with directly."

I'd rank them:

Medusa → Saleor → commercetools

But the distinction is important:

• TypeScript + maximum backend customization: → Medusa
• GraphQL-first frontend: → Saleor
• Large enterprise/composable architecture: → commercetools
• Commerce should mostly be someone else's operational problem: → Shopify
• Want SaaS but more API flexibility: → BigCommerce

One thing I'd not optimize for is simply "does it have an API?" Almost all modern headless platforms do. The more important question is how much of the commerce domain can you actually customize without fighting the platform.

For a custom frontend, I'd evaluate catalog modeling, pricing/promotions, checkout, customer accounts, inventory, webhooks/events, custom entities, authentication, and how easily you can introduce your own business logic. That's where the platforms diverge substantially. saleor.iocommercetools.comdocs.medusajs.com

If you tell me your stack (e.g. Next.js + TypeScript), database, expected traffic, B2C/B2B, and whether you need subscriptions/marketplace/multi-vendor, I can narrow this to a specific architecture and recommend the best one.

If flexibility + APIs are your top priorities and you're building the frontend yourself, I’d shortlist Medusa, Saleor, and commercetools. My default pick for a developer-led custom build would be Medusa.

1. 🥇 Medusa — my pick for maximum developer control

Medusa documentation

Medusa is particularly attractive if you're building your own frontend and potentially your own business logic. Its storefront is completely separate from the backend, and its Store API is REST-based. You can also add your own API routes, data models, workflows, and modules. docs.medusajs.com

The architecture is roughly:

Your Frontend
    │
    ├── REST / Store API
    ├── Custom API routes
    │
    ▼
Medusa
    │
    ├── Products
    ├── Cart
    ├── Checkout
    ├── Customers
    ├── Orders
    ├── Inventory
    └── Your custom modules

That's a very good fit if you're using Next.js, React, Vue, Svelte, mobile apps, or multiple frontends.

The big advantage is that you're not merely customizing someone else's commerce platform—you can actually extend the commerce engine itself.

2. 🥈 Saleor — best if you love GraphQL

Saleor

If your frontend architecture is heavily GraphQL-oriented, I'd seriously consider Saleor.

Saleor is API-only and GraphQL-native, with the entire storefront/admin experience sitting on top of its API. It also has webhooks, metadata, apps, API extensions, and native multi-channel support. github.com

That makes it particularly nice for a frontend like:

Next.js / React
       │
       │ GraphQL
       ▼
    Saleor
       │
       ├── Catalog
       ├── Pricing
       ├── Channels
       ├── Checkout
       ├── Orders
       └── Customers

I'd choose Saleor over Medusa if your team strongly prefers GraphQL and Python/Django isn't a problem.

3. 🥉 commercetools — best for serious enterprise commerce

commercetools

For a large enterprise with complicated pricing, catalogs, markets, B2B requirements, multiple channels, etc., commercetools is arguably the strongest option.

Its commerce APIs are explicitly designed to be consumed directly by custom frontends and integrations, with SDKs for several languages. docs.commercetools.com

The tradeoff is cost and complexity. I'd avoid it for a relatively simple store unless there's a compelling enterprise requirement.

What I'd choose

If I were building your stack today:

• Maximum control / developer experience → Medusa
• GraphQL-first architecture → Saleor
• Enterprise / complex B2B → commercetools
• Need Shopify's ecosystem and operational simplicity → Shopify headless
• Want a middle ground between Shopify and fully custom → BigCommerce

For a developer building a truly custom frontend, I wouldn't choose based primarily on storefront features. I'd evaluate:

1. Can I model my domain without fighting the platform?
2. Can I extend checkout/order/pricing logic?
3. How good are the APIs?
4. Can I consume everything without platform-specific frontend components?
5. How good are webhooks/events?
6. Can I use my own search, CMS, payments, tax, ERP, PIM, etc.?
7. Can I run multiple storefronts/channels from one backend?
8. Can I migrate away later?

On those criteria, Medusa and Saleor are particularly compelling because they're designed around API-first/headless usage rather than treating headless as an additional presentation layer. naturaily.com

My personal starting point: Next.js + Medusa + PostgreSQL + a headless CMS + dedicated search, unless you specifically want GraphQL everywhere—in which case I'd start with Saleor.

If you’re the developer building a genuinely custom frontend, I’d narrow it to Medusa, Saleor, Shopify, and commercetools. There isn’t one universal winner—the key question is how much of the commerce backend you want to own.

My ranking for flexibility + APIs

🥇 I'd pick Medusa for a developer-first custom frontend

Medusa documentation

If your priority is "I want the commerce engine to adapt to my application", rather than adapting your application to the commerce platform, Medusa is probably the most interesting choice.

Medusa v2 exposes REST Store APIs and lets you create your own API routes. It's also built around a modular backend, so you can extend/customize the commerce logic rather than treating the commerce platform as a black box. docs.medusajs.com

I'd especially consider it if you're building:

• Next.js/React frontend
• custom checkout
• unusual pricing/promotions
• marketplace-like functionality
• subscriptions or custom fulfillment
• complex integrations
• your own backend services around commerce
• a product where commerce is part of the application, rather than the entire application

The tradeoff is that you own more infrastructure and commerce complexity.

🥈 Saleor if you love GraphQL

Saleor is particularly attractive if your frontend architecture is strongly GraphQL-oriented. It's open source and gives you considerably more backend control than Shopify while avoiding some of the architectural work of building a commerce engine yourself.

I'd pick Saleor over Medusa if your team is already heavily invested in Python/Django and GraphQL.

🥉 Shopify if you want to minimize commerce infrastructure

Shopify developer documentation

Don't dismiss Shopify just because you're building headless. Its Storefront API is GraphQL and supports products, collections, carts, checkout, customers, contextual pricing, etc. Shopify explicitly supports using your own framework—including Next.js, Vue, or essentially any HTTP client. shopify.dev

The big advantage is that you get a very mature commerce backend/admin ecosystem while completely controlling the customer-facing frontend.

Shopify's current headless architecture also lets you use its Headless channel with the Storefront API and Customer Account API while bringing your own stack. shopify.dev

I'd choose Shopify when:

"I want a completely custom frontend, but I don't want to spend six months building/maintaining commerce infrastructure."

That's a very compelling proposition.

🏢 commercetools for serious enterprise composability

commercetools

If you're building a large-scale composable commerce architecture—multiple markets, currencies, catalogs, B2B pricing, ERP/PIM integrations, multiple channels, etc.—I'd put commercetools near the top.

But for a typical startup/custom storefront, I'd probably consider it excessive compared with Medusa or Shopify.

What I'd choose based on the architecture

Next.js + completely custom business logic + maximum control

→ Medusa

Next.js + GraphQL everywhere + Python team

→ Saleor

Next.js + custom UX + want mature commerce operations

→ Shopify

Enterprise + composable architecture + complex B2B/multimarket

→ commercetools

You want to essentially build your own commerce platform

→ Medusa

One important distinction: "headless" doesn't necessarily mean "flexible." Shopify is excellent at headless presentation, but you're still operating within Shopify's commerce model. Medusa/Saleor give you substantially more control over the underlying model and backend behavior.

For a developer starting a new custom frontend today, I'd personally prototype with Medusa and Shopify side-by-side. If Medusa's APIs and data model fit your requirements, its flexibility is hard to beat; if you find yourself recreating functionality Shopify already provides, Shopify will likely win on total engineering effort. powergatesoftware.com

If you tell me your stack (Next.js/Nuxt/etc.), B2C vs B2B, subscriptions/marketplace needs, and whether you want self-hosting), I can give you a much more concrete recommendation and architecture.

If flexibility + API quality are your top criteria, I’d shortlist Medusa, commercetools, and Saleor. My default pick for a developer building a truly custom frontend would be Medusa.

My pick: Medusa

For a custom frontend, Medusa is particularly attractive because the storefront is completely decoupled. You can build it with Next.js, React, Vue, native mobile, or essentially anything that can consume HTTP APIs. Its Store API is REST-based, and it also provides a JS SDK. docs.medusajs.com

The bigger advantage is that you're not limited to consuming a fixed commerce API. Medusa lets you add custom API routes, data models, workflows, and modules, so the backend can evolve around your application's domain rather than forcing your frontend to work around the platform. docs.medusajs.com

For example, if you need:

Custom React/Next.js frontend
        ↓
Your BFF / API layer
        ↓
Medusa
   ├── Products
   ├── Pricing
   ├── Cart
   ├── Orders
   ├── Inventory
   ├── Payments
   └── Your custom modules

that's a very natural architecture for Medusa.

When I'd choose commercetools instead

If this is enterprise-scale—multiple countries, B2B, complex catalogs/pricing, multiple storefronts/channels, lots of integrations—I'd seriously consider commercetools.

Its APIs are extremely mature and designed around composable commerce. It also has extensive API extensibility through custom fields, custom objects, API extensions, subscriptions, and states. Importantly, commercetools explicitly recommends a middleware layer when you're building a custom frontend because that gives you maximum control over the APIs. docs.medusajs.comdocs.commercetools.com

So:

Maximum developer freedom → Medusa
Maximum enterprise composability → commercetools

When Saleor makes more sense

If your team is strongly GraphQL-oriented, Saleor is compelling. Its API is GraphQL-first and its documentation exposes a substantial GraphQL API/reference plus extension and app mechanisms. docs.saleor.io

I'd put it ahead of Medusa if your team specifically wants GraphQL as the primary contract between frontend and commerce backend.

What I'd choose by project

• Startup / new product / highly custom UX: Medusa
• Custom marketplace or unusual commerce model: Medusa
• TypeScript/Node-heavy team: Medusa or Vendure
• GraphQL-first architecture: Saleor
• Large enterprise / B2B / multi-market: commercetools
• Need Shopify's ecosystem and merchant tooling: Shopify headless
• Want maximum backend ownership: Medusa or Saleor

One important distinction: "headless" doesn't automatically mean flexible. Shopify, for example, gives you an excellent headless frontend experience, but you're still operating within Shopify's commerce model. Medusa and commercetools are better choices if the commerce backend itself needs to be shaped around your application.

If you tell me your stack (Next.js/React/etc.), expected scale, B2C vs B2B, and whether you want self-hosted or SaaS, I can narrow this to a specific recommendation and architecture.

If your priority is maximum frontend flexibility + strong APIs, I’d shortlist these four:

My pick: Saleor

For a developer building a completely custom frontend, I'd lean Saleor.

It's genuinely API-first rather than a traditional ecommerce platform with a headless layer bolted on. The entire platform is accessible through GraphQL, and it supports webhooks, apps, metadata, API extensions, and granular permissions. It also supports multiple channels natively. github.com

That makes it particularly attractive if your architecture looks something like:

Next.js / React / native app → BFF → Saleor → payments / search / CMS / ERP

You aren't forced to use a particular frontend framework or proprietary storefront.

Saleor developer documentation

Medusa is the one I'd investigate next

Medusa may actually be better if by "flexibility" you mean "I want to modify the commerce engine itself."

Medusa gives you a Node.js-based framework where you can add data models, modules, workflows, API routes, and custom business logic. Its storefront APIs are REST-based, and you can use its JS SDK or call the REST APIs directly. docs.medusajs.com

So I'd characterize them:

• Saleor: "Give me a powerful commerce backend and let me compose around it."
• Medusa: "Give me a commerce framework that I can reshape."

Medusa documentation

commercetools if this is enterprise

commercetools is probably the strongest choice if you're building for a large organization with complex catalogs, markets, B2B, integrations, and multiple commerce channels.

It has both HTTP and GraphQL APIs, extensive API specifications/SDKs, and is designed explicitly around composable/headless architecture. docs.commercetools.com

The downside is that it's considerably more enterprise-oriented than Medusa or Saleor.

commercetools API documentation

Don't dismiss Shopify

If you want custom frontend without owning commerce infrastructure, Shopify is still compelling. Its Storefront API is GraphQL and supports products, collections, carts and checkout; Hydrogen gives you an official React-based headless stack. shopify.dev

But if your definition of flexibility includes changing the underlying commerce model/business logic, I'd choose Saleor or Medusa instead.

My decision rule:

• 🥇 Saleor → maximum API/frontend freedom with a mature commerce core
• 🥈 Medusa → maximum ability to customize the backend itself
• 🥉 commercetools → maximum enterprise/composable capability
• Shopify → maximum operational simplicity while retaining a custom frontend

If you tell me your stack (e.g. Next.js + TypeScript), expected scale, B2C/B2B, and whether you want to self-host, I can narrow this down to the best architecture for your project.

If your priorities are maximum frontend freedom + strong APIs + the ability to customize commerce logic, I’d shortlist Medusa, Saleor, and commercetools—with Medusa as my default pick for a developer-led custom build.

My recommendation: Medusa

For a developer building a custom frontend, I'd start with Medusa.

Its architecture is unusually developer-friendly: the storefront is completely separate from the commerce backend, and you can build your frontend with whatever stack you want. Medusa exposes Store APIs and lets you add your own API routes. docs.medusajs.com

The bigger advantage is that you're not limited to extending commerce through external APIs. Medusa's framework gives you modules, workflows, data models, and custom API routes, so custom business logic can live inside the commerce application rather than becoming a collection of middleware services. docs.medusajs.com

For example, if your business needs:

Custom React/Next.js frontend
          ↓
      Your BFF/API
          ↓
      Medusa APIs
       ↙       ↘
   Commerce   Custom modules
   modules      / workflows
       ↓
   PostgreSQL

that's a very natural architecture for it.

When I'd choose Saleor instead

Saleor is probably my #2 choice, and potentially #1 if GraphQL is a major requirement.

Saleor is GraphQL-native, headless, open source, and designed to work with essentially any frontend/BFF stack. It also provides extensive webhooks and extension mechanisms. docs.saleor.io

I'd pick it if your team is particularly comfortable with Python/Django + GraphQL and you want a very API-centric architecture.

When commercetools wins

commercetools becomes more attractive when you're building for a large enterprise with complicated B2B/B2C requirements, multiple markets, channels, or a genuinely composable architecture.

It advertises 500+ commerce APIs and a large integration ecosystem, with commerce functionality decomposed into composable services. commercetools.com

The downside is that you're buying enterprise infrastructure and complexity when you may not need it.

What I'd pick by scenario

• Next.js/React + TypeScript + highly custom product → Medusa
• GraphQL-first architecture → Saleor
• Enterprise, multinational, complex B2B → commercetools
• Want Shopify's ecosystem/operations but custom frontend → Shopify
• TypeScript + GraphQL + very deep backend customization → Vendure

If you're starting from scratch today, I'd lean Medusa unless you have a specific reason to prefer GraphQL (Saleor) or enterprise composability (commercetools). Its combination of TypeScript, REST APIs, modular commerce domains, custom workflows, and custom data models makes it particularly well suited to a developer-owned frontend/backend architecture. docs.medusajs.com

If you tell me your stack (Next.js/React/etc.), expected scale, B2B vs B2C, and whether you need subscriptions/multi-vendor/multi-region, I can narrow this down to a concrete architecture and recommend the API strategy I'd use.

If flexibility + APIs are your top priorities for a custom frontend, my shortlist in 2026 would be:

My pick: Saleor

For a developer building the frontend yourself, I'd lean toward Saleor.

It's genuinely API-first rather than a traditional ecommerce platform that happens to expose APIs. Its core API is GraphQL, and the platform exposes products, checkout, payments, shipping, promotions, channels, etc. through the API. It also supports webhooks, apps, metadata, API extensions, and dashboard extensions. docs.saleor.io

That makes a stack like:

Next.js / React → your BFF → Saleor GraphQL → your services

very natural.

Saleor documentation

But consider Medusa if you want to modify the commerce engine

Medusa is arguably even more flexible from a backend-engineering perspective.

Medusa is Node/TypeScript-oriented and gives you a framework for adding custom data models, workflows, modules, API routes, integrations, and event handlers. Its storefront is completely separate from the backend, so you're free to use essentially any frontend stack. docs.medusajs.com

Its Store API is REST/OpenAPI-based, which can also be attractive if you prefer conventional HTTP APIs over GraphQL. docs.medusajs.com

Medusa documentation

The decision I'd make

Choose Saleor if:

• Your frontend is heavily custom.
• You like GraphQL and generated TypeScript types.
• You want a clean API-only architecture.
• You expect multiple storefronts/channels.
• You want to extend commerce without forking the core.

Choose Medusa if:

• You're comfortable owning more backend code.
• Your business has unusual commerce logic.
• You want to build custom modules/workflows directly into the commerce backend.
• Your team is primarily TypeScript/Node.
• REST APIs are preferable.

Choose commercetools if:

• This is a large enterprise implementation.
• You need sophisticated B2B, pricing, markets, and composable architecture.
• Budget and operational complexity aren't major constraints.

Choose Shopify if:

• You want the easiest operational path.
• Checkout, payments, apps, and merchant tooling matter more than backend freedom.
• You're happy to work within Shopify's data/model constraints.

For a developer-first custom frontend

I'd rank them:

1. Saleor — best overall API-first choice
2. Medusa — best for maximum customization
3. commercetools — best enterprise option
4. BigCommerce — best pragmatic SaaS option
5. Shopify — best ecosystem/operations, not maximum backend flexibility

One important distinction: "headless" doesn't automatically mean "flexible." The thing I'd investigate hardest is whether the platform lets you change the commerce model and business logic, not merely whether it gives you a Storefront API.

If you tell me your stack (e.g. Next.js + TypeScript + PostgreSQL) and whether you're doing DTC, B2B, marketplace, subscriptions, or something unusual, I can narrow this down to 1–2 choices and compare the actual APIs/architecture.

If flexibility + API quality are your top priorities for a custom frontend, I’d shortlist Medusa, Saleor, and commercetools—with Medusa as my default pick for a developer-led custom build.

🥇 My pick: Medusa

For a developer building their own frontend, Medusa is particularly compelling because the storefront is completely separate from the commerce backend. You can use essentially any frontend stack and consume its Store APIs or your own custom API routes. docs.medusajs.com

More importantly, you're not just customizing the frontend—you can customize the commerce engine itself. Medusa's framework lets you add API routes, workflows, data models, modules, integrations, and event subscribers. docs.medusajs.com

The current v2 API is REST-based and has separate Store and Admin APIs, with an OpenAPI specification available for tooling. docs.medusajs.com

So if you're building something like:

Your Next.js / React / Vue / mobile frontend
                 ↓
            Your BFF/API
                 ↓
        ┌─────────────────┐
        │     Medusa      │
        │                 │
        │ products        │
        │ carts           │
        │ customers       │
        │ orders          │
        │ pricing         │
        │ inventory       │
        │ fulfillment     │
        └─────────────────┘
          ↓       ↓      ↓
       Stripe    ERP    Custom services

…it gives you a lot of room to make the architecture your own.

Medusa documentation

🥈 Saleor if you want GraphQL

I'd choose Saleor over Medusa if your team strongly prefers GraphQL.

Saleor is genuinely API-first: its core API is GraphQL-only, and its storefront/admin functionality is designed to be consumed through APIs rather than a traditional monolithic frontend. It also has native multichannel support and extensive webhook/app extension capabilities. saleor.io

That's especially attractive if your frontend is heavily typed and you want queries like:

query Product($slug: String!) {
  products(filter: { slug: $slug }) {
    edges {
      node {
        id
        name
        pricing {
          priceRange {
            start {
              gross {
                amount
                currency
              }
            }
          }
        }
        variants {
          id
          name
        }
      }
    }
  }
}

rather than stitching together REST endpoints.

Saleor documentation

🏢 commercetools if you're building enterprise commerce

If this is a large-scale B2B/B2C system, especially with multiple markets, catalogs, pricing systems, currencies, regions, and external services, I'd seriously consider commercetools.

The tradeoff is complexity and cost. You're buying into a composable enterprise platform rather than getting a lightweight commerce engine you can bend however you want.

What I'd choose

Small/medium developer team + maximum control:
→ Medusa

GraphQL-first architecture:
→ Saleor

Enterprise / complex composable architecture:
→ commercetools

You want Shopify's ecosystem but your own frontend:
→ Shopify

One important distinction: "headless" doesn't automatically mean "flexible." Shopify is excellent at headless storefronts, but Medusa/Saleor give you substantially more control over the commerce backend itself.

If you tell me your stack (e.g. Next.js + TypeScript + Postgres) and whether you need B2B, subscriptions, multi-vendor, multi-region, or just standard DTC, I can narrow this down to a specific architecture and recommend the API approach I'd use.