ChatGPT answers, unedited

For an agency building custom frontends repeatedly across clients, I’d narrow the shortlist to Vendure, Medusa, and commercetools, with the right choice depending on what you mean by “multi-tenant.”

Vendure explicitly documents a multi-tenant architecture where multiple shops can run in one Vendure instance, with a Channel per tenant and tenant-specific permissions/configuration. Vendure Medusa also supports multiple stores within one instance, although its own documentation notes that native multi-tenancy isn't provided and that you build the association/isolation between stores and their resources. Medusa Documentation

What I'd recommend for an agency

1. Vendure — if multi-tenancy is a core requirement

I'd seriously consider making Vendure your agency's default commerce backend if your clients need things like:

• One backend serving multiple stores/brands
• Separate product catalogs, pricing, inventory, etc.
• Custom Next.js/React frontends
• Strong TypeScript integration
• GraphQL APIs
• Custom checkout/business logic
• B2B as well as B2C
• Marketplace-like or multi-brand architectures

Its Channel abstraction maps unusually well to the agency scenario: one commerce deployment → many client/store contexts → independently customized frontends. Vendure itself documents using Channels to create multi-tenant setups. Vendure

Its current storefront stack is also Next.js/React/TypeScript with GraphQL, while allowing you to replace the frontend entirely with your own. Vendure

2. Medusa — if your agency prioritizes flexibility

I'd choose Medusa when your team wants a more modular, developer-oriented commerce engine and is comfortable implementing the tenant abstraction itself.

It's particularly attractive if your standard agency stack is:

Next.js + TypeScript + Postgres + custom integrations

Medusa's architecture gives you considerable freedom to build custom commerce workflows rather than forcing clients into a predefined SaaS model. The important caveat for your use case is that multi-store ≠ fully implemented multi-tenancy: Medusa lets you manage multiple stores, but tenant isolation and the relationships between resources require your architecture. Medusa Documentation

That can actually be an advantage for an agency if you want to create your own reusable tenant layer once and reuse it across projects.

3. commercetools — when the client is enterprise

For a large retailer or enterprise client, I'd move toward commercetools rather than trying to turn an open-source engine into an enterprise commerce platform.

It's API-first/composable and designed for organizations with complex catalogs, markets, channels, integrations and multiple commerce experiences. The tradeoff is that you're buying into a much more enterprise-oriented platform and operating model. Current industry comparisons generally put commercetools alongside the enterprise composable platforms rather than the developer-oriented engines. Vendure

The architecture I'd build for your agency

If you're trying to create a repeatable agency offering, I'd actually standardize the frontend/backend boundary rather than standardizing the entire website:

                    ┌─────────────────────┐
                    │   Agency Frontend   │
                    │ Next.js / React     │
                    └──────────┬──────────┘
                               │
                         Commerce API
                               │
                    ┌──────────▼──────────┐
                    │   Vendure / Medusa  │
                    │                     │
                    │ Tenant A            │
                    │ Tenant B            │
                    │ Tenant C            │
                    │ ...                 │
                    └──────────┬──────────┘
                               │
             ┌─────────────────┼─────────────────┐
             ▼                 ▼                 ▼
          Payments          ERP/CRM            CMS
          Stripe/etc.       Client systems     Content

Then your agency owns a reusable frontend starter:

agency-commerce/
├── storefront/
│   ├── product/
│   ├── collection/
│   ├── cart/
│   ├── checkout/
│   └── account/
├── components/
├── commerce/
│   ├── products.ts
│   ├── cart.ts
│   ├── checkout.ts
│   └── customer.ts
├── tenant/
│   ├── configuration.ts
│   ├── branding.ts
│   └── routing.ts
└── cms/

Each client then gets its own:

tenant
├── domain
├── branding
├── catalog
├── pricing
├── payment configuration
├── CMS content
└── frontend configuration

That gives you the agency equivalent of a commerce operating system: your clients get genuinely custom frontends, while your team doesn't reinvent product/catalog/cart/checkout infrastructure for every engagement.

My practical shortlist

If I were evaluating this for an agency today, I'd do a technical spike with:

Vendure vs. Medusa

and only bring in commercetools when the client requirements justify an enterprise SaaS platform.

The key question I'd test isn't “which has the most features?” It's “can we provision a new tenant/store, isolate its data, connect a custom Next.js frontend, and deploy it repeatedly without bespoke engineering?”

If multi-tenant SaaS commerce is actually the product you're building for your clients—not merely multiple storefronts for one merchant—I'd lean toward Vendure as the starting point, because its Channel model maps directly onto that architecture. Vendure

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

Here are the platforms I’d shortlist:

My recommendation by agency model

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

Architecture:

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

Pros:

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

Tradeoff:

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

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

Architecture:

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

This lets your agency build:

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

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

Good when clients need:

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

A stack I’d standardize for a modern frontend agency

Frontend

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

Commerce

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

Content

• Contentful, Sanity, or another headless CMS

Search

• Algolia or Elasticsearch/OpenSearch

Payments

• Stripe where possible

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

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

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

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

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

If your agency’s core business is building custom frontends, I’d make BigCommerce your default recommendation, with Shopify Plus and commercetools as the two main alternatives.

My recommendation

Why I'd pick BigCommerce for an agency

BigCommerce is unusually well aligned with your model: you can treat the platform as the commerce backend and build essentially whatever frontend architecture the client wants.

Its GraphQL Storefront API supports custom storefronts, carts, customers, products, etc., and BigCommerce explicitly supports multiple headless storefronts/channels from one store. BigCommerce BigCommerce

More importantly for an agency, its Multi-Storefront functionality lets you maintain multiple sites with different branding, pricing, and configurations from a centralized backend. BigCommerce BigCommerce

That gives you a nice architecture:

                    Your agency
                         │
              ┌──────────┴──────────┐
              │   Shared frontend   │
              │   components/BFF    │
              └──────────┬──────────┘
                         │
                  BigCommerce APIs
                         │
       ┌─────────────────┼─────────────────┐
       │                 │                 │
    Store A           Store B           Store C
   Client A          Client B          Client C
       │                 │                 │
    Catalog           Catalog           Catalog
    Pricing           Pricing           Pricing
    Orders            Orders            Orders
    Customers         Customers         Customers

You can standardize your agency's stack around Next.js + your component system + BigCommerce APIs, while still delivering highly differentiated experiences.

BigCommerce also has a Next.js/React-oriented Catalyst option, while its APIs allow you to go completely custom if you don't want to use their frontend framework. BigCommerce

Where Shopify Plus fits

Shopify is probably the best commercial choice when client success depends more on Shopify's ecosystem than on architectural flexibility.

Shopify's Storefront API is genuinely strong and framework-agnostic—you can use Next.js, Vue, Hydrogen, etc. Shopify Shopify

The catch for your particular business is the tenant/store model. Shopify's headless channel can create multiple storefronts for a shop, but there is a limit of 100 active storefronts/tokens per shop. Shopify

So I'd position Shopify as:

"We use Shopify Plus when the client wants Shopify's ecosystem, administration, checkout, and app marketplace, while we provide a completely custom frontend."

Not necessarily:

"We use Shopify as the backend for a multi-tenant commerce platform."

Those are different requirements.

When I'd move up to commercetools

commercetools becomes interesting when you're dealing with enterprise multi-brand/multi-region commerce, complicated pricing, B2B, multiple catalogs, sophisticated promotions, ERP integration, etc.

It's much closer to a true composable commerce backend than Shopify.

The downside is that you're taking on significantly more implementation complexity. For a typical $50k–$200k client website, that's often unnecessary.

And if you want to own the platform...

I'd investigate Medusa.

That's the option I'd consider if your agency eventually wants to offer something like:

"We have our own multi-tenant commerce backend and deploy a custom storefront for every client."

You get substantially more control than with SaaS platforms, but you also inherit hosting, upgrades, security, infrastructure, operational responsibility, and more commerce functionality that you'd otherwise get from BigCommerce/Shopify.

The positioning I'd use for your agency

I'd actually productize the decision:

• BigCommerce → default for custom/headless builds
• Shopify Plus → clients prioritizing Shopify ecosystem, apps, operational simplicity
• commercetools → enterprise/composable/complex multi-market commerce
• Medusa → clients requiring deep backend customization or platform ownership

That gives your agency a repeatable architecture rather than choosing a different commerce backend from scratch for every project.

If by "multi-tenant" you specifically mean your agency wants one backend/platform instance where dozens or hundreds of independent client stores are tenants, rather than one merchant operating multiple storefronts, I'd make a somewhat different recommendation. In that case, Medusa/Saleor/commercetools vs. BigCommerce becomes a much more interesting architectural decision.

Its GraphQL Storefront API supports custom storefronts, carts, customers, products, etc., and BigCommerce explicitly supports multiple headless storefronts/channels from one store. BigCommerce BigCommerce

More importantly for an agency, its Multi-Storefront functionality lets you maintain multiple sites with different branding, pricing, and configurations from a centralized backend. BigCommerce BigCommerce

That gives you a nice architecture:

                    Your agency
                         │
              ┌──────────┴──────────┐
              │   Shared frontend   │
              │   components/BFF    │
              └──────────┬──────────┘
                         │
                  BigCommerce APIs
                         │
       ┌─────────────────┼─────────────────┐
       │                 │                 │
    Store A           Store B           Store C
   Client A          Client B          Client C
       │                 │                 │
    Catalog           Catalog           Catalog
    Pricing           Pricing           Pricing
    Orders            Orders            Orders
    Customers         Customers         Customers

You can standardize your agency's stack around Next.js + your component system + BigCommerce APIs, while still delivering highly differentiated experiences.

BigCommerce also has a Next.js/React-oriented Catalyst option, while its APIs allow you to go completely custom if you don't want to use their frontend framework. BigCommerce

Where Shopify Plus fits

Shopify is probably the best commercial choice when client success depends more on Shopify's ecosystem than on architectural flexibility.

Shopify's Storefront API is genuinely strong and framework-agnostic—you can use Next.js, Vue, Hydrogen, etc. Shopify Shopify

The catch for your particular business is the tenant/store model. Shopify's headless channel can create multiple storefronts for a shop, but there is a limit of 100 active storefronts/tokens per shop. Shopify

So I'd position Shopify as:

"We use Shopify Plus when the client wants Shopify's ecosystem, administration, checkout, and app marketplace, while we provide a completely custom frontend."

Not necessarily:

"We use Shopify as the backend for a multi-tenant commerce platform."

Those are different requirements.

When I'd move up to commercetools

commercetools becomes interesting when you're dealing with enterprise multi-brand/multi-region commerce, complicated pricing, B2B, multiple catalogs, sophisticated promotions, ERP integration, etc.

It's much closer to a true composable commerce backend than Shopify.

The downside is that you're taking on significantly more implementation complexity. For a typical $50k–$200k client website, that's often unnecessary.

And if you want to own the platform...

I'd investigate Medusa.

That's the option I'd consider if your agency eventually wants to offer something like:

"We have our own multi-tenant commerce backend and deploy a custom storefront for every client."

You get substantially more control than with SaaS platforms, but you also inherit hosting, upgrades, security, infrastructure, operational responsibility, and more commerce functionality that you'd otherwise get from BigCommerce/Shopify.

The positioning I'd use for your agency

I'd actually productize the decision:

• BigCommerce → default for custom/headless builds
• Shopify Plus → clients prioritizing Shopify ecosystem, apps, operational simplicity
• commercetools → enterprise/composable/complex multi-market commerce
• Medusa → clients requiring deep backend customization or platform ownership

That gives your agency a repeatable architecture rather than choosing a different commerce backend from scratch for every project.

If by "multi-tenant" you specifically mean your agency wants one backend/platform instance where dozens or hundreds of independent client stores are tenants, rather than one merchant operating multiple storefronts, I'd make a somewhat different recommendation. In that case, Medusa/Saleor/commercetools vs. BigCommerce becomes a much more interesting architectural decision.

If your agency’s core proposition is “we build the frontend; the client needs a commerce backend with APIs and multiple stores/tenants,” I’d make BigCommerce and Shopify Plus your default shortlist, with Saleor/Medusa for clients who need much deeper control.

My recommendation

🥇 I'd probably standardize on BigCommerce

For an agency, BigCommerce is particularly attractive because its Multi-Storefront capability lets you operate multiple storefronts from one account while giving each storefront its own look, feel and pricing configuration. Its GraphQL Storefront API is designed for custom storefronts, and it also supports custom checkout experiences. BigCommerce BigCommerce

That maps very nicely to an agency architecture:

                    YOUR AGENCY
                         │
             ┌───────────┴───────────┐
             │   Shared Frontend     │
             │  Next.js / React      │
             │  Design system        │
             │  Components           │
             └───────────┬───────────┘
                         │
                    API / BFF
                         │
             ┌───────────┴───────────┐
             │     BigCommerce       │
             │                       │
       ┌─────┼─────┬─────┬─────────┐
       │     │     │     │         │
     Store A B     C     D       ...
       │     │     │     │
     Client  Client Client Client

You can build a reusable frontend framework where the tenant/store configuration determines things like:

• branding/theme
• domain
• catalog
• pricing
• navigation
• CMS content
• locales/currencies
• feature flags
• integrations

while your agency maintains one underlying frontend architecture.

BigCommerce explicitly positions Multi-Storefront for multiple brands, customer segments and regions, and its headless offering lets developers choose their own frontend and other components. BigCommerce

Shopify Plus is the other obvious choice

Shopify is probably the easier sell to clients who already know Shopify.

Its Storefront API is framework-agnostic, so you can use Next.js, Hydrogen, Vue, etc., rather than being locked into Shopify's frontend. Shopify's Headless channel also supports creating multiple custom storefronts. Shopify Shopify

The important distinction for your agency is that Shopify's model isn't quite the same as “one SaaS instance containing arbitrary tenants.” A Storefront API token is associated with a particular Shopify store, and Shopify documents a maximum of 100 active storefronts/access tokens per shop. Shopify

So I'd position Shopify Plus as:

Best when the client wants Shopify's ecosystem, admin, payments and operational maturity, while your agency owns the experience layer.

Whereas BigCommerce is attractive when multi-storefront is itself a central requirement.

Where Saleor / Medusa become interesting

If by multi-tenant you mean something stronger than:

“One client has multiple branded stores.”

and instead mean:

“Our agency is building a SaaS where hundreds of independent merchants each get their own store, catalog, pricing, users and configuration.”

then I'd seriously investigate Saleor or Medusa.

That's a fundamentally different architecture.

You'd potentially have:

                  Your SaaS
                     │
          ┌──────────┴──────────┐
          │   Tenant Resolver   │
          └──────────┬──────────┘
                     │
       ┌─────────────┼─────────────┐
       ▼             ▼             ▼
    Tenant A      Tenant B      Tenant C
       │             │             │
    Catalog        Catalog        Catalog
    Orders         Orders         Orders
    Users          Users          Users
       └─────────────┬─────────────┘
                     ▼
              Commerce API
                     │
                 Frontend

Saleor is particularly compelling if GraphQL and a highly customizable commerce layer are priorities. Medusa is compelling if your developers want a more code-centric, extensible Node/TypeScript commerce backend. Current headless comparisons commonly put both in the open-source/custom-control category. PowerGate Software Vendure

And commercetools?

For enterprise clients with complex requirements—multiple markets, currencies, catalogs, B2B pricing, ERP integration, composable architecture—I'd put commercetools on the shortlist.

But I wouldn't make it your default agency platform unless your clients are large enough to justify the additional architecture and commercial complexity. It's much more of an enterprise composable commerce play than a “give us a backend and we'll build your storefront” play. Naturaily Netguru

What I'd do if this were my agency

I'd establish three standardized offerings:

1. Standard Headless — BigCommerce

• Next.js
• BigCommerce APIs
• Multi-Storefront
• CMS of choice
• Your agency's reusable design system
• Default recommendation
• Shopify Headless — Shopify Plus

• Next.js/Hydrogen
• Storefront API
• Shopify admin/ecosystem
• Best for clients already invested in Shopify
• Composable / SaaS Commerce — Saleor or Medusa

• Your own frontend/platform
• Maximum backend customization
• Stronger fit when your agency's application itself is multi-tenant
• More engineering/operations responsibility

The key question I'd ask before choosing is: when you say multi-tenant, do you mean one enterprise owning multiple stores/brands, or your agency is building a SaaS platform where many independent clients each have their own store?

Those lead to very different platform recommendations.

The important distinction for your agency is that Shopify's model isn't quite the same as “one SaaS instance containing arbitrary tenants.” A Storefront API token is associated with a particular Shopify store, and Shopify documents a maximum of 100 active storefronts/access tokens per shop. Shopify

So I'd position Shopify Plus as:

Best when the client wants Shopify's ecosystem, admin, payments and operational maturity, while your agency owns the experience layer.

Whereas BigCommerce is attractive when multi-storefront is itself a central requirement.

Where Saleor / Medusa become interesting

If by multi-tenant you mean something stronger than:

“One client has multiple branded stores.”

and instead mean:

“Our agency is building a SaaS where hundreds of independent merchants each get their own store, catalog, pricing, users and configuration.”

then I'd seriously investigate Saleor or Medusa.

That's a fundamentally different architecture.

You'd potentially have:

                  Your SaaS
                     │
          ┌──────────┴──────────┐
          │   Tenant Resolver   │
          └──────────┬──────────┘
                     │
       ┌─────────────┼─────────────┐
       ▼             ▼             ▼
    Tenant A      Tenant B      Tenant C
       │             │             │
    Catalog        Catalog        Catalog
    Orders         Orders         Orders
    Users          Users          Users
       └─────────────┬─────────────┘
                     ▼
              Commerce API
                     │
                 Frontend

Saleor is particularly compelling if GraphQL and a highly customizable commerce layer are priorities. Medusa is compelling if your developers want a more code-centric, extensible Node/TypeScript commerce backend. Current headless comparisons commonly put both in the open-source/custom-control category. powergatesoftware.com vendure.io

And commercetools?

For enterprise clients with complex requirements—multiple markets, currencies, catalogs, B2B pricing, ERP integration, composable architecture—I'd put commercetools on the shortlist.

But I wouldn't make it your default agency platform unless your clients are large enough to justify the additional architecture and commercial complexity. It's much more of an enterprise composable commerce play than a “give us a backend and we'll build your storefront” play.

What I'd do if this were my agency

I'd establish three standardized offerings:

For an agency building custom frontends for multiple clients, I’d avoid picking a platform based only on “headless support.” The key question is whether you need:

1. Many independent storefronts (multi-tenant SaaS model)
2. Many brands/stores under one merchant organization
3. Enterprise composable commerce
4. Fast client launches with minimal backend ownership

My shortlist would be:

1. Medusa — best fit for an agency building a reusable commerce platform

Recommend when: you want to build a repeatable “commerce engine + custom frontend” offering.

Strengths:

• API-first and designed for custom storefronts. Medusa Docs
• You can model multiple stores, sales channels, catalogs, pricing rules, etc. within one deployment. Medusa documents store management and multi-store patterns through its Store Module. Medusa Docs
• Open source gives your agency more control over architecture and margins.
• Great pairing: - Frontend: Next.js / React / Remix
• CMS: Sanity, Contentful, Payload, Strapi
• Commerce: Medusa
• Search: Algolia / Elasticsearch
• Hosting: AWS / Render / Fly / Kubernetes

Tradeoff:

• Your team owns more infrastructure, upgrades, and custom commerce logic.

Agency fit: 9/10

2. Shopify — best for client velocity

Recommend when: clients want to launch quickly and need mature operations.

Strengths:

• Excellent headless APIs through the Storefront API. Shopify
• Strong admin, payments, inventory, apps, and merchant tooling.
• Multiple headless storefronts can be created through Shopify's Headless channel. Shopify
• Your agency focuses on premium frontend experiences instead of commerce infrastructure.

Typical stack:

• Next.js or Hydrogen frontend
• Shopify Storefront API
• Shopify Admin for operations

Tradeoff:

• Multi-tenant SaaS patterns are not really its strength. Usually each client is its own Shopify store.
• Custom workflows can hit platform boundaries.

Agency fit: 8.5/10

3. commercetools — enterprise option

Recommend when: clients are large retailers, manufacturers, marketplaces, or B2B enterprises.

Strengths:

• True composable commerce architecture.
• Strong for: - multiple brands
• multiple regions
• complex pricing
• B2B workflows
• large catalogs

Tradeoff:

• Higher implementation complexity.
• Longer sales cycles.
• Usually requires enterprise budgets.

Agency fit: 8/10 (enterprise only)

4. BigCommerce — middle ground

Good when clients want:

• SaaS reliability
• headless APIs
• less custom backend work than Medusa

Tradeoff:

• Less flexible than a true composable platform.

My recommended agency positioning

I would create two service tiers:

Tier 1: “Custom storefronts”

Use:

• Shopify backend
• Next.js/Hydrogen frontend

For:

• DTC brands
• marketing-driven ecommerce
• companies needing speed

Tier 2: “Commerce platform builds”

Use:

• Medusa (default)
• commercetools for enterprise

For:

• marketplaces
• multi-brand operators
• franchises
• clients wanting a platform they own

If your goal is specifically “one platform where our agency can host hundreds of client storefronts as tenants”, I would lean toward Medusa or Vendure/Saleor-style open architectures, not Shopify. If your goal is “build the best frontend experience on top of proven commerce backends,” Shopify is usually the easier sell. vendure.io ribbsaetersystems.com

A strong agency architecture would probably be:

Next.js frontend → API gateway → commerce backend (Medusa) → CMS → search → payments

with tenant isolation handled at the commerce/data layer.

Yes. For an agency building custom frontends for multiple clients, I’d narrow the shortlist to Shopify Plus, commercetools, and Medusa rather than recommending a generic ecommerce platform.

My default recommendation: Shopify Plus

For most agency clients, I’d recommend Shopify Plus + a custom Next.js/Hydrogen frontend.

Shopify gives you the managed commerce backend—catalog, inventory, checkout, orders, payments, etc.—while your agency owns the frontend. Its Storefront API is framework-agnostic, so you can use Next.js, React, Vue, etc. Shopify Shopify

It also has a Headless channel specifically for managing multiple custom storefronts, including separate API credentials and permissions. Shopify

shopify.dev

The important distinction, though, is what you mean by multi-tenant:

• Agency serving many independent clients: Shopify works extremely well. Each client gets their own Shopify store, and your agency deploys the same frontend architecture against each store.
• One SaaS platform containing hundreds/thousands of independent merchants: I'd lean toward Medusa or commercetools, because you have much more control over tenant provisioning and isolation.
• Enterprise clients with complicated catalogs, B2B pricing, markets, currencies, and business rules: commercetools is probably the strongest architectural fit.

How I'd position the three

Shopify Plus is the "don't make the client reinvent commerce" option. Your agency can build a reusable frontend system and connect it to each client's Shopify backend. Shopify explicitly supports bringing your own frontend stack. Shopify Shopify

commercetools is better when commerce itself needs to be highly composable. It's particularly attractive for complex B2B, multi-market and enterprise architectures. Naturaily Kiwop

Medusa is the interesting one if your agency wants to build a reusable multi-tenant platform, rather than simply build websites for clients. Its architecture allows tenant-specific routing, separate Medusa instances/databases, provisioning, and custom modules/workflows. Medusa

The architecture I'd build for an agency

If your business model is:

"We build custom storefronts for 20–100 brands, but want one reusable frontend platform."

I'd seriously consider:

Next.js → your frontend component/design system → tenant resolver → Shopify Storefront API

with something like:

                    ┌── Client A Shopify
                    │
                    ├── Client B Shopify
Next.js Frontend ───┼── Client C Shopify
                    │
                    └── Client D Shopify
                           │
                    Storefront API

Your application can resolve the tenant from the domain:

nike-client.com       → shopify_store_a
acme-client.com       → shopify_store_b
foo-client.com        → shopify_store_c

Then your agency owns the frontend, design system, deployment pipeline, CMS integration, analytics and personalization, while the client owns their commerce backend.

That gives you a very scalable agency model without making your team responsible for maintaining payments, orders, inventory, checkout infrastructure, etc.

One caveat: if by "multi-tenant" you mean a single backend where your agency provisions isolated stores for hundreds of merchants, don't automatically choose Shopify. In that scenario I'd prototype Medusa vs. commercetools first.

If you tell me whether you're building (A) many separate client stores or (B) one SaaS platform with many merchants, I can recommend the architecture and platform much more precisely.

For an agency building custom frontends for clients, I’d avoid choosing a single platform for every project. You want a commerce backend that gives your team a strong API layer, supports multiple storefronts/brands, and doesn’t fight your frontend architecture. The shortlist I’d recommend is:

1. commercetools — best enterprise multi-tenant/composable choice

Recommend when: enterprise clients, multi-brand retailers, complex B2B, multiple regions, custom pricing, marketplaces.

Strengths:

• True API-first commerce model
• Designed for multiple brands, channels, and regions
• Flexible product/catalog/pricing modeling
• Excellent fit for Next.js, React, mobile apps, kiosks, etc.
• Lets your agency own the experience layer

Tradeoffs:

• More engineering required
• Clients need budget and operational maturity
• You build more of the surrounding ecosystem yourself

This is the platform I’d position as the "enterprise custom commerce" offering. Naturaily Vendure

2. BigCommerce — best agency default

Recommend when: mid-market brands that want custom UX without enterprise complexity.

Strengths:

• Mature headless APIs
• Managed hosting, payments, security, and operations
• Easier merchant adoption than fully composable platforms
• Works well with custom React/Next.js storefronts
• Good balance between flexibility and speed

Tradeoffs:

• Less deeply customizable than a pure commerce engine
• You work within BigCommerce’s commerce model

For many agency projects, this is probably the safest default. It gives developers freedom while keeping clients comfortable. BigCommerce BigCommerce

3. Shopify + headless APIs — best for DTC brands

Recommend when: consumer brands, marketing-heavy stores, clients already using Shopify.

Strengths:

• Huge ecosystem
• Excellent merchant tooling
• Fast client onboarding
• Strong checkout/payment infrastructure
• Easy handoff after launch

Tradeoffs:

• Multi-tenant usually means multiple Shopify stores rather than one deeply modeled commerce instance
• Less ideal for unusual B2B workflows or marketplace logic

Good agency productization opportunity: "custom storefront on Shopify." Online Store News Ribbsaeter Systems

4. Saleor / Medusa — best when you want ownership

Recommend when: startups, marketplaces, unusual business models, clients who want control.

Strengths:

• Open source
• Highly customizable
• API-first
• Better fit for bespoke commerce logic

Tradeoffs:

• Your agency becomes partially responsible for infrastructure and upgrades
• More ongoing maintenance

Good if you want to sell a "commerce platform engineering" retainer. Vendure Ribbsaeter Systems

How I’d package this as an agency

My agency default stack would probably be:

• Frontend: Next.js + React
• CMS: Sanity / Contentful / Strapi
• Commerce: BigCommerce for most clients, commercetools for enterprise
• Search: Algolia / Elastic
• Personalization: client-specific services
• Hosting: Vercel / AWS

The key question is whether your "multi-tenant" requirement means:

1. one platform serving many client stores (agency SaaS model), or
2. each client needs multiple storefronts/brands/regions.

Those lead to very different architecture choices.

For an agency building custom frontends for multiple clients, I’d make BigCommerce the default recommendation, with Shopify Plus and commercetools as alternatives depending on the client.

My recommendation

1. BigCommerce — best agency default

BigCommerce is particularly well suited to your model because it has:

• Multi-Storefront: multiple storefronts/brands/regions can run from one backend, with separate domains, currencies, catalogs, pricing, and presentation. BigCommerce BigCommerce
• Headless GraphQL + REST APIs, explicitly designed for custom/headless storefronts. BigCommerce BigCommerce
• Next.js/Catalyst support, so your agency can standardize on a modern frontend architecture while clients retain BigCommerce's commerce backend. BigCommerce
• B2B capabilities if your client mix includes wholesale or complex customer accounts. BigCommerce
• A useful separation between your frontend/IP and the client's commerce operations.

The architecture I'd sell would be:

                    ┌─────────────────────┐
                    │    BigCommerce      │
                    │   Commerce Backend  │
                    └──────────┬──────────┘
                               │
                    GraphQL / REST APIs
                               │
              ┌────────────────┴────────────────┐
              │                                 │
       Client Store A                     Client Store B
       Next.js frontend                  Next.js frontend
              │                                 │
       Custom design/CMS                  Custom design/CMS

That gives your agency a repeatable implementation without forcing every client into the same visual experience.

2. Shopify Plus — best when clients want the Shopify ecosystem

I'd recommend Shopify when the client's priority is merchant usability, ecosystem, checkout, and speed to launch.

Shopify's Storefront API is framework-agnostic and supports custom storefronts, including Next.js and other frameworks. Shopify Shopify

The caveat for your particular requirement is that Shopify's Storefront API is fundamentally tied to an individual Shopify shop; Shopify documents a maximum of 100 active storefront access tokens per shop. Shopify

So I'd think of Shopify more as:

one commerce tenant → potentially multiple custom storefront experiences

rather than choosing it specifically because you want a deeply multi-tenant commerce architecture.

3. commercetools — for genuinely enterprise multi-tenant/composable projects

If by "multi-tenant" you mean your agency wants to build something closer to:

one commerce infrastructure → many brands/markets/business units → highly customized commerce rules

then I'd look seriously at commercetools.

It's the choice I'd investigate for large enterprise clients with complicated catalogs, pricing, B2B relationships, markets, and integrations. The tradeoff is substantially more implementation complexity than BigCommerce or Shopify.

How I'd position them to clients

If I were building your agency's standard stack today, I'd start with BigCommerce + Next.js + a headless CMS, and create your own reusable frontend/tenant layer on top. BigCommerce's Multi-Storefront and API model maps unusually well to an agency that needs to repeatedly launch distinct custom storefronts. BigCommerce BigCommerce

If you tell me whether by "multi-tenant" you mean multiple clients on one SaaS platform, multiple stores for one client, or an agency-owned platform hosting hundreds of stores, I can narrow this down considerably—the best platform is different for each architecture.

For an agency building custom frontends for multiple clients, I would avoid choosing a platform based only on “headless support.” Your bigger requirement is usually:

• tenant isolation (one client/store does not affect another)
• repeatable provisioning (launch store #20 like store #1)
• API-first commerce primitives
• white-label/custom frontend freedom
• manageable operations for your team

The best recommendation depends on whether you want to be a solution integrator (fast client delivery) or build a commerce platform layer yourself.

My shortlist for an agency model

Guideflow Vendure## Recommendation by agency strategy

Option 1: “We want to launch lots of client stores quickly”

Recommend: Shopify headless

Architecture:

Client Store
   |
Custom Next.js / React Frontend
   |
Shopify Storefront API
   |
Shopify Admin

Why:

• Clients already understand the admin experience.
• Huge ecosystem.
• Your agency owns the frontend differentiation.
• Easy handoff after launch.

Shopify supports custom storefronts through its Storefront API, which exposes products, carts, pricing, and checkout capabilities for custom experiences. Shopify

Downside:

• Each client is usually a separate Shopify store.
• You are not really building a multi-tenant commerce SaaS; you are managing many stores.

Option 2: “We want our agency to own a reusable commerce platform”

Recommend: Vendure or Medusa

Architecture:

Agency Commerce Platform

Tenant A
  └── Storefront A

Tenant B
  └── Storefront B

Tenant C
  └── Storefront C

        |
     Commerce API
        |
 Database + Services

This lets you create:

• tenant provisioning
• reusable components
• shared integrations
• your own admin layer
• standardized deployments

Vendure is particularly interesting if your agency is TypeScript-heavy because it is built around NestJS and GraphQL with a plugin model. Vendure

Medusa is attractive if you want a modular Node.js commerce backend that your team can extend heavily. Vendure

Option 3: “We serve enterprise clients”

Recommend: commercetools

Use when clients need:

• multiple brands
• multiple regions
• complex pricing
• B2B workflows
• ERP integrations

It is designed as composable commerce infrastructure rather than a traditional storefront platform. Guideflow

The tradeoff is implementation complexity and enterprise sales cycles.

What I would avoid as an agency platform

WooCommerce

Good for individual projects, but difficult to standardize across dozens of tenants.

Adobe Commerce/Magento

Powerful, but operational overhead is high unless you have dedicated enterprise infrastructure.

Building commerce from scratch

You will spend years rebuilding:

• carts
• promotions
• tax logic
• inventory
• checkout
• order management

My practical agency stack recommendation

For most agencies today:

Tier 1: Client delivery engine

• Frontend: Next.js
• CMS: Contentful or Sanity
• Commerce: Shopify headless

Tier 2: Your own scalable platform

• Frontend: Next.js
• Commerce: Vendure or Medusa
• Database: PostgreSQL
• Hosting: Kubernetes/Vercel/Cloudflare depending on needs
• Tenant model: schema-per-tenant or tenant ID isolation

If your agency expects to launch 10–100+ storefronts on the same underlying system, I would lean toward Vendure. If you expect mostly branded client builds with separate ownership, I would lean toward Shopify headless. Shopify Vendure

A useful question is: Are you trying to become the commerce platform behind your clients, or are you trying to deliver the best custom storefronts on top of someone else's commerce engine? The answer changes the recommendation.

For an agency building custom frontends for multiple clients, I’d make Medusa the default recommendation, with Saleor and Shopify as alternatives depending on the client.

My recommendation

1. Medusa — best agency default

Medusa is particularly well suited to the model you described:

• Fully headless — storefronts are separate applications, so your team can use Next.js, React, Vue, etc. Medusa Documentation Medusa Documentation
• REST APIs + JS SDK — straightforward for custom frontend development. Medusa Documentation Medusa Documentation
• Multiple stores in one instance — Medusa supports creating/managing multiple stores, although it explicitly says multi-tenancy itself isn't native. You'd implement tenant isolation around its Store/module architecture. Medusa Documentation
• Sales channels give you another useful isolation layer for different storefronts, markets, or channels. Medusa Documentation Medusa Documentation
• Highly extensible backend — custom modules, data models, workflows and API routes mean you're not boxed into the platform's native commerce model. Medusa Documentation Medusa Documentation
• It works particularly well if your agency wants to maintain a reusable frontend + commerce architecture rather than reinventing the backend for every client.

The important caveat: don't pitch Medusa as "native multi-tenant SaaS." Its own docs say multi-tenancy isn't native. If your agency wants one deployment → hundreds of completely isolated merchant tenants, you'll need to design that architecture yourself. Medusa Documentation

2. Saleor — strongest alternative

I'd look seriously at Saleor if your clients need more sophisticated multi-channel, international, B2B, or GraphQL-heavy commerce.

Saleor has native multi-channel functionality and a fully headless GraphQL API, and its architecture is explicitly designed around multiple storefronts/channels. Saleor Documentation Saleor Commerce

I'd choose it over Medusa when your agency has a strong GraphQL/Python team and the clients have more enterprise commerce requirements.

3. Shopify — best for clients who prioritize operations

Shopify is still the safer recommendation when the client cares more about getting commerce running with minimal backend ownership than having maximum backend control.

Its Storefront API supports headless builds, and Shopify's Headless channel can manage multiple custom storefronts. Shopify

The downside for an agency building highly customized systems is that you're ultimately designing around Shopify's commerce model rather than owning the entire commerce backend.

How I'd position them to clients

The architecture I'd build for your agency

If you're trying to create a repeatable agency platform, I'd actually separate the concepts:

                    ┌─────────────────────┐
                    │   Your Agency SaaS  │
                    │                     │
                    │ Tenant / Client     │
                    │ Domain / Branding   │
                    │ Feature Flags       │
                    │ Store Configuration │
                    └──────────┬──────────┘
                               │
                  ┌────────────▼────────────┐
                  │       Medusa            │
                  │                         │
                  │ Products / Customers    │
                  │ Cart / Checkout         │
                  │ Orders / Payments       │
                  │ Inventory / Pricing     │
                  └────────────┬────────────┘
                               │
              ┌────────────────┼────────────────┐
              ▼                ▼                ▼
        Client Store A   Client Store B   Client Store C
        Next.js          Next.js          Next.js
        Custom UI        Custom UI        Custom UI

Then your agency owns a common commerce abstraction, while each client gets a completely custom presentation layer.

That is where I think Medusa is particularly attractive: the storefront is deliberately decoupled from the commerce backend, and you can expose your own API routes and workflows on top of the commerce primitives. Medusa Documentation Medusa Documentation

If I were standardizing your agency today, I'd shortlist Medusa + Saleor and make Medusa the default. The deciding question is whether by "multi-tenant" you mean multiple storefronts/brands or a genuine Shopify-like SaaS where each tenant has isolated data, users, billing, domains, catalog, and orders. The latter changes the architecture substantially.

If your agency’s core model is “we build the frontend, while the commerce platform provides the backend,” I’d shortlist these:

My default recommendation: Shopify Plus

For an agency, Shopify Plus is probably the safest platform to standardize on.

Its Storefront API is specifically designed for custom storefronts and is framework-agnostic—you can use Next.js, React, Vue, etc. Shopify Shopify

More importantly for your model, Plus supports expansion stores under an organization. Those stores have independent products/settings/storefronts while administration, users and billing can be managed centrally. Shopify Help Center Shopify Help Center

That gives you a useful agency architecture:

                    Agency Frontend
                         │
              ┌──────────┴──────────┐
              │   Shared frontend   │
              │  Next.js / React    │
              └──────────┬──────────┘
                         │
              ┌──────────┴──────────┐
              │   Commerce API      │
              └──────────┬──────────┘
                         │
       ┌─────────────────┼─────────────────┐
       ▼                 ▼                 ▼
   Client A          Client B          Client C
   Shopify           Shopify           Shopify
   Store             Store             Store

You can also maintain a shared frontend codebase with tenant/store configuration determining the Shopify store, branding, catalog behavior, CMS content, etc.

Shopify's current headless tooling includes the Storefront API, Hydrogen, and Oxygen, while you can alternatively use your own Next.js/Vercel stack. Shopify Shopify

When I'd choose commercetools instead

If you're targeting large enterprise clients with genuinely complex multi-brand/multi-region requirements, I'd take a serious look at commercetools.

Its Store abstraction is particularly compelling: stores can represent brands, regions, physical locations, etc., and API permissions can be scoped to individual stores. It currently documents up to 300,000 stores per project as a soft limit. commercetools Documentation

That's closer to a true multi-tenant commerce architecture than simply having multiple independent ecommerce sites.

The tradeoff is that your agency will own substantially more of the implementation/integration work.

When I'd choose Medusa

Medusa is attractive if your agency wants to own the commerce architecture rather than primarily implement on top of a SaaS platform.

It has a Store module that lets you create/manage multiple stores within one Medusa instance, but importantly, Medusa explicitly says that native multi-tenancy isn't supported. You'd build the tenant isolation/customization layer yourself. Medusa Docs

So I'd position it as:

Shopify Plus = productized agency platform
commercetools = enterprise composable platform
Medusa = maximum engineering control

What I'd recommend for an agency

I'd actually standardize on two tiers rather than one platform:

• 80% of clients: Shopify Plus + your agency's reusable Next.js frontend framework.
• Enterprise clients: commercetools when they need sophisticated tenant/brand/region/catalog/permission modeling.
• Medusa: only when a client has a strong reason to own/customize the commerce backend itself.

One important distinction: if by “multi-tenant” you mean your agency operates hundreds of completely separate client stores from one application/control plane, rather than one enterprise has multiple brands/stores, that changes my recommendation considerably. In that case, I'd evaluate the platforms specifically as SaaS/multi-tenant infrastructure, not merely multi-store ecommerce.

If that's your model, I can lay out a recommended agency architecture + platform comparison for 10, 100, and 1,000 client stores.

More importantly for your model, Plus supports expansion stores under an organization. Those stores have independent products/settings/storefronts while administration, users and billing can be managed centrally. Shopify Help Center Shopify Help Center

That gives you a useful agency architecture:

                    Agency Frontend
                         │
              ┌──────────┴──────────┐
              │   Shared frontend   │
              │  Next.js / React    │
              └──────────┬──────────┘
                         │
              ┌──────────┴──────────┐
              │   Commerce API      │
              └──────────┬──────────┘
                         │
       ┌─────────────────┼─────────────────┐
       ▼                 ▼                 ▼
   Client A          Client B          Client C
   Shopify           Shopify           Shopify
   Store             Store             Store

You can also maintain a shared frontend codebase with tenant/store configuration determining the Shopify store, branding, catalog behavior, CMS content, etc.

Shopify's current headless tooling includes the Storefront API, Hydrogen, and Oxygen, while you can alternatively use your own Next.js/Vercel stack. Shopify Shopify

When I'd choose commercetools instead

If you're targeting large enterprise clients with genuinely complex multi-brand/multi-region requirements, I'd take a serious look at commercetools.

Its Store abstraction is particularly compelling: stores can represent brands, regions, physical locations, etc., and API permissions can be scoped to individual stores. It currently documents up to 300,000 stores per project as a soft limit. commercetools Documentation

That's closer to a true multi-tenant commerce architecture than simply having multiple independent ecommerce sites.

The tradeoff is that your agency will own substantially more of the implementation/integration work.

When I'd choose Medusa

Medusa is attractive if your agency wants to own the commerce architecture rather than primarily implement on top of a SaaS platform.

It has a Store module that lets you create/manage multiple stores within one Medusa instance, but importantly, Medusa explicitly says that native multi-tenancy isn't supported. You'd build the tenant isolation/customization layer yourself.

So I'd position it as:

For an agency building custom frontends, I’d make BigCommerce the default recommendation, with Shopify Plus and Medusa as alternatives depending on the client.

My recommendation: BigCommerce

BigCommerce is a particularly good agency platform because it gives you a strong commerce backend while leaving the presentation layer almost completely in your hands.

• Headless-first APIs: GraphQL Storefront API covers catalog, customers, carts, checkout, and other core storefront operations. BigCommerce BigCommerce
• Multiple storefronts/channels: BigCommerce's Multi-Storefront architecture lets you associate different sites, catalogs, categories, and products with channels. BigCommerce BigCommerce
• Custom frontend: You can build with Next.js/React or essentially whatever frontend stack you want. Their Catalyst framework is itself Next.js + React + GraphQL. BigCommerce BigCommerce
• Good agency separation: Your frontend code, hosting, design system, CMS, and deployment can be your agency's concern while the client gets BigCommerce's admin for commerce operations.
• B2B: The B2B GraphQL API supports companies, users, roles, quotes, shopping lists, orders, invoices, etc. BigCommerce

One important distinction: if by multi-tenant you mean your agency operates one SaaS platform containing hundreds of completely independent merchants, BigCommerce's model isn't quite the same as a true multi-tenant commerce engine. You'd generally provision/manage separate stores/accounts and build your own tenant layer.

How I'd position the options

When I'd choose Shopify Plus instead

Shopify Shopify Plus is probably the safer choice if the client prioritizes the Shopify ecosystem, apps, operational simplicity, and a proven enterprise platform.

Plus supports expansion stores under an organization, with centralized billing/user management while each store retains its own settings, configurations, and storefront. Shopify Help Center Shopify Help Center It is also explicitly optimized for headless implementations through Shopify's API layer. Shopify

I'd generally say:

BigCommerce when the frontend is the product. Shopify Plus when the commerce ecosystem is the product.

When I'd choose Medusa

Medusa becomes interesting if multi-tenancy itself is a core requirement.

For example, imagine you're building:

Your Agency Platform
        │
        ├── Tenant A → Storefront A
        ├── Tenant B → Storefront B
        ├── Tenant C → Storefront C
        └── Tenant D → Storefront D
                │
             Commerce
                │
       Products / Orders / Cart
       Payments / Inventory / Pricing

In that situation, a programmable commerce engine can be more attractive than trying to make Shopify/BigCommerce behave like a SaaS platform. Medusa has a strong developer-oriented architecture and first-class sales-channel concepts; recent agency implementations have used it specifically for multi-store scenarios. Pinwheel Agency

What I'd standardize at your agency

If you're looking for one platform to build a repeatable agency offering around, I'd start with:

Next.js + BigCommerce GraphQL + your preferred CMS + your own design system/deployment infrastructure.

Then create a reusable architecture where:

                 ┌── CMS
                 │
Next.js ─────────┼── BigCommerce
                 │
                 ├── Search
                 │
                 ├── Analytics
                 │
                 └── Client-specific integrations

That gives you a repeatable frontend codebase while keeping commerce functionality out of your custom application.

If you tell me what you mean by multi-tenant (e.g. one client with 10 brands, your agency hosts 100 client stores, or a SaaS marketplace where merchants sign themselves up), I can narrow this down substantially—the best platform is different for each architecture.

For an agency building custom frontends for multiple clients, I’d recommend choosing a platform that treats commerce as an API layer rather than a theme system. The right choice depends on whether you are building many independent client stores or a true SaaS multi-tenant commerce platform.

My shortlist:

Shopify Guideflow## My recommendation for an agency

Option A — Agency building individual client sites

Use Shopify headless.

Architecture:

Client A Shopify Store
        |
        | Storefront API
        |
   Next.js / React frontend

Client B Shopify Store
        |
        | Storefront API
        |
   Next.js / React frontend

Pros:

• Clients get a mature admin
• Payments, tax, inventory, apps, fulfillment already solved
• Your team focuses on UX/frontend
• Easier handoff after launch

Shopify's Storefront API is designed specifically for custom storefronts and supports building experiences outside Shopify themes. Shopify

This is probably the safest default recommendation.

Option B — You want to build your own "Shopify for verticals"

Use Medusa.

Architecture:

                Agency Platform
                      |
        ------------------------------
        |              |             |
     Tenant A       Tenant B      Tenant C
        |              |             |
    Storefront     Storefront    Storefront
        |
     Medusa API

You build:

• tenant management
• billing
• onboarding
• permissions
• analytics
• custom admin layer

Medusa is attractive because it is modular and API-driven. Its Store Module supports managing multiple stores within one instance, though a full SaaS multi-tenancy layer usually requires additional architecture from you. Medusa Documentation Medusa Documentation

Good use cases:

• franchise networks
• marketplaces
• multi-brand retailers
• industry-specific commerce SaaS

Option C — Enterprise clients

Use commercetools.

Typical clients:

• global brands
• multiple countries/currencies
• complex B2B pricing
• ERP-heavy environments

It is powerful but usually requires more architecture work and a larger implementation budget.

What I would standardize on as an agency

I would probably create a two-tier offering:

"Custom Storefront Package"

• Shopify backend
• Next.js frontend
• Headless CMS
• Custom integrations

For 80% of clients.

"Commerce Platform Package"

• Medusa backend
• Multi-tenant layer
• Next.js storefronts
• Custom admin
• Subscription billing

For clients who want a platform rather than a website.

That gives you a repeatable delivery model without forcing every client into the complexity of a custom commerce engine.

A few questions would change the recommendation:

1. Are you building separate stores for clients, or a single SaaS platform where many merchants sign up?
2. Do clients need their own admin dashboards?
3. Are these mostly B2C stores, B2B portals, marketplaces, or franchise/location-based stores?

That gives you a repeatable delivery model without forcing every client into the complexity of a custom commerce engine.

A few questions would change the recommendation:

Yes. For an agency building custom frontends for multiple clients, I’d narrow the recommendation to BigCommerce, Medusa, and Shopify Plus—but they solve slightly different problems.

My default recommendation: BigCommerce

BigCommerce is probably the best agency-friendly default if your requirement is:

• Custom React/Next.js frontends
• Multiple storefronts/channels per merchant
• Headless APIs
• A managed backend rather than infrastructure you have to operate
• Clients ranging from mid-market to enterprise

BigCommerce has explicit Multi-Storefront / Multi-Channel functionality, and its APIs support headless storefronts. Its GraphQL Storefront API covers catalog, customer, cart, and checkout functionality. BigCommerce BigCommerce

The important distinction is that BigCommerce gives you multi-storefront capabilities inside a managed commerce platform, whereas some "multi-tenant" headless platforms require you to build the tenancy model yourself.

If you mean true SaaS-style multi-tenancy: Medusa

Medusa is extremely interesting for an agency.

Medusa's Store Module supports multiple stores within one instance, although multi-tenancy isn't native—you implement the tenant relationships/customizations yourself. Medusa Docs Its storefronts are completely separate applications, and the Store API is designed specifically for custom storefronts. Medusa Docs Medusa Docs

That makes an architecture like this possible:

                    Agency Platform
                          │
             ┌────────────┴────────────┐
             │                         │
        Client A                   Client B
        tenant_001                 tenant_002
             │                         │
       ┌─────┴─────┐             ┌─────┴─────┐
       │            │             │            │
    Next.js      Next.js       Next.js      Next.js
    Storefront   Admin         Storefront   Admin
       │            │             │            │
       └────────────┴─────────────┴────────────┘
                          │
                       Medusa
                          │
                    REST / APIs

Medusa is particularly attractive if your agency wants to own the frontend architecture and extend the commerce backend, rather than adapting every client to Shopify's model. It also has documented recipes for marketplaces, vendor models, custom APIs, and custom admin experiences. Medusa Docs Medusa Docs

The catch: you are taking on more engineering responsibility.

Shopify Plus: best for conventional client work

Shopify / Shopify Plus is what I'd recommend when the client values:

• Lowest operational burden
• Mature payments/checkout
• Huge app ecosystem
• Fast implementation
• Enterprise reliability

It's also perfectly viable for headless storefronts. But if your agency's selling point is "we build one multi-tenant commerce platform and deploy highly customized stores for many independent clients," Shopify is less elegant architecturally. You generally end up thinking in terms of separate Shopify stores rather than one deeply customizable tenant-aware commerce backend.

How I'd position the three

What I'd actually do for your agency

If you're saying "we want a platform that lets our agency build a reusable commerce foundation, then give every client a totally custom frontend", I'd seriously evaluate:

1. BigCommerce — safest commercial recommendation
2. Medusa — best if you want to build your own multi-tenant platform/IP
3. Shopify Plus — best if clients prioritize ecosystem, checkout, and low maintenance

One nuance is particularly important: don't confuse "multi-storefront" with "multi-tenant." BigCommerce explicitly supports many storefronts/channels within a merchant's commerce environment. BigCommerce Medusa can support multiple stores in one instance, but its docs explicitly say you need to build the multi-tenancy relationships yourself. Medusa Docs

If your agency's goal is to onboard 50–500 client stores onto the same underlying platform, I'd lean Medusa + your own tenant layer. If the goal is build 10–50 sophisticated client stores without becoming a commerce-platform company, I'd lean BigCommerce.

If your agency builds custom frontends for clients, I’d make Medusa the default platform you recommend, with Vendure and Shopify Plus as alternatives depending on the client.

The important distinction is whether by “multi-tenant” you mean one platform serving many independent client stores, versus one merchant having multiple storefronts/channels.

My recommendation

🥇 I'd start with Medusa

medusajs.com

For an agency, Medusa is particularly attractive because you're essentially getting a commerce backend that you can put your own frontend architecture around. It's TypeScript/Node-based, open source, and designed for custom commerce rather than forcing clients into a particular storefront. Current comparisons also highlight its modular architecture and suitability for custom checkout and marketplace-style implementations. Vendure Ribbsaeter Systems

That maps nicely to an agency model:

                    Your Agency
                         │
              ┌──────────┴──────────┐
              │                     │
        Shared platform        Shared components
              │                     │
       ┌──────┼──────┐              │
       │      │      │              │
     Store A Store B Store C     Next.js/Astro/etc.
       │      │      │
       └──────┴──────┘
              │
           Medusa
              │
     ┌────────┼─────────┐
   Products  Orders    Customers
     │        │          │
   Payments Inventory  Promotions

You can standardize your agency's frontend stack while keeping the commerce backend sufficiently flexible for different clients.

🥈 Consider Vendure if "multi-tenant" is the core requirement

vendure.io

Vendure is especially compelling if you're building B2B, multi-channel, multi-brand, or more sophisticated commerce systems. It's TypeScript/NestJS/GraphQL and has a strong plugin/extensibility model. Its multi-channel architecture is particularly relevant when one backend needs to support different storefronts, catalogs, currencies, or markets. Vendure Listicler

I'd seriously evaluate Vendure if your agency wants to build a repeatable commerce platform/product of your own, rather than merely implementing stores for individual clients.

🥉 Shopify Plus when clients don't want infrastructure

shopify.com

If the client says:

"We want a completely custom frontend, but we don't want our agency maintaining the commerce backend."

Then Shopify Plus becomes extremely attractive. Shopify's Storefront API/Hydrogen approach gives you a custom frontend while Shopify handles the underlying commerce infrastructure. The tradeoff is that you're accepting Shopify's backend and platform constraints rather than owning the commerce engine. Vendure

One architectural question I'd settle first

If you're envisioning something like:

"Our agency has one platform, and we can spin up Store A, Store B, Store C for different clients, each with isolated products, orders, customers, branding, domains, etc."

I'd not automatically assume that a normal "multi-store" feature equals true multi-tenancy.

I'd design your architecture around explicit tenant isolation:

                    Agency Commerce Platform
                              │
                    ┌─────────┴─────────┐
                    │     Tenant ID     │
                    └─────────┬─────────┘
                 ┌────────────┼────────────┐
                 ▼            ▼            ▼
              Tenant A     Tenant B     Tenant C
                 │            │            │
              Store A      Store B      Store C
                 │            │            │
              Domain A     Domain B     Domain C
                 │            │            │
              Frontend A   Frontend B   Frontend C

Then put your reusable agency layer above the commerce engine:

Next.js/Astro → your frontend components → commerce adapter → Medusa/Vendure

That adapter is important. It means you can offer clients:

• Medusa for highly customized/open deployments
• Vendure for sophisticated multi-channel/B2B requirements
• Shopify for managed clients

without rewriting your entire frontend architecture.

If I were standardizing an agency stack today: Next.js + TypeScript + Medusa as the default, with Vendure for complex multi-tenant/B2B cases and Shopify Plus for clients prioritizing managed SaaS. This gives you a much stronger reusable architecture than making Shopify the backend for every client. Vendure Ribbsaeter Systems

If you tell me whether your “multi-tenant” model is one client = one store or one client can own multiple stores/brands, I can recommend the specific architecture and tenancy model I'd use.

For an agency, Medusa is particularly attractive because you're essentially getting a commerce backend that you can put your own frontend architecture around. It's TypeScript/Node-based, open source, and designed for custom commerce rather than forcing clients into a particular storefront. Current comparisons also highlight its modular architecture and suitability for custom checkout and marketplace-style implementations. Vendure Ribbsaeter Systems

That maps nicely to an agency model:

                    Your Agency
                         │
              ┌──────────┴──────────┐
              │                     │
        Shared platform        Shared components
              │                     │
       ┌──────┼──────┐              │
       │      │      │              │
     Store A Store B Store C     Next.js/Astro/etc.
       │      │      │
       └──────┴──────┘
              │
           Medusa
              │
     ┌────────┼─────────┐
   Products  Orders    Customers
     │        │          │
   Payments Inventory  Promotions

You can standardize your agency's frontend stack while keeping the commerce backend sufficiently flexible for different clients.

🥈 Consider Vendure if "multi-tenant" is the core requirement

vendure.io

Vendure is especially compelling if you're building B2B, multi-channel, multi-brand, or more sophisticated commerce systems. It's TypeScript/NestJS/GraphQL and has a strong plugin/extensibility model. Its multi-channel architecture is particularly relevant when one backend needs to support different storefronts, catalogs, currencies, or markets. Vendure Listicler

I'd seriously evaluate Vendure if your agency wants to build a repeatable commerce platform/product of your own, rather than merely implementing stores for individual clients.

🥉 Shopify Plus when clients don't want infrastructure

shopify.com

If the client says:

"We want a completely custom frontend, but we don't want our agency maintaining the commerce backend."

Then Shopify Plus becomes extremely attractive. Shopify's Storefront API/Hydrogen approach gives you a custom frontend while Shopify handles the underlying commerce infrastructure. The tradeoff is that you're accepting Shopify's backend and platform constraints rather than owning the commerce engine. Vendure

One architectural question I'd settle first

If you're envisioning something like:

"Our agency has one platform, and we can spin up Store A, Store B, Store C for different clients, each with isolated products, orders, customers, branding, domains, etc."

I'd not automatically assume that a normal "multi-store" feature equals true multi-tenancy.

I'd design your architecture around explicit tenant isolation:

                    Agency Commerce Platform
                              │
                    ┌─────────┴─────────┐
                    │     Tenant ID     │
                    └─────────┬─────────┘
                 ┌────────────┼────────────┐
                 ▼            ▼            ▼
              Tenant A     Tenant B     Tenant C
                 │            │            │
              Store A      Store B      Store C
                 │            │            │
              Domain A     Domain B     Domain C
                 │            │            │
              Frontend A   Frontend B   Frontend C

Then put your reusable agency layer above the commerce engine:

Next.js/Astro → your frontend components → commerce adapter → Medusa/Vendure

That adapter is important. It means you can offer clients:

• Medusa for highly customized/open deployments
• Vendure for sophisticated multi-channel/B2B requirements
• Shopify for managed clients

without rewriting your entire frontend architecture.

If I were standardizing an agency stack today: Next.js + TypeScript + Medusa as the default, with Vendure for complex multi-tenant/B2B cases and Shopify Plus for clients prioritizing managed SaaS. This gives you a much stronger reusable architecture than making Shopify the backend for every client.

For an agency building custom frontends repeatedly for different clients, I’d make BigCommerce the default recommendation, with Shopify Plus and commercetools as alternatives depending on the client.

My recommendation

Why I'd pick BigCommerce

BigCommerce's Multi-Storefront architecture lets a merchant run multiple storefronts/channels from one commerce backend, with different sites, catalogs, pricing, and customer experiences. BigCommerce BigCommerce

That's particularly attractive for an agency because you can establish a reusable architecture like:

                 Your Agency Platform
                         │
              ┌──────────┴──────────┐
              │                     │
        Custom Next.js         Custom Next.js
          Frontend A             Frontend B
              │                     │
              └──────────┬──────────┘
                         │
                 BigCommerce APIs
                         │
          ┌──────────────┼──────────────┐
          │              │              │
       Store A        Store B        Store C
       Brand A        Brand B        Brand C

The GraphQL Storefront API gives you products, categories, customers, carts and checkout, while the Management APIs handle administrative/commerce operations. BigCommerce BigCommerce

BigCommerce also explicitly supports connecting multiple customized storefronts and positioning the commerce backend separately from the frontend. BigCommerce

And if your team standardizes on Next.js, BigCommerce's Catalyst gives you a ready-made composable/headless reference architecture built around Next.js, React Server Components and the GraphQL Storefront API. BigCommerce

Where Shopify fits

I'd recommend Shopify Plus when the client is primarily a DTC brand and wants the lowest operational burden.

Shopify's Storefront API is framework-agnostic, so your agency can use Next.js, Hydrogen, Vue, etc. Shopify Shopify It also has a Headless channel where you can create multiple custom storefronts with separate API tokens. Shopify

The catch is that Shopify's "multiple storefronts" model isn't quite the same thing as having many isolated tenants inside one commerce project. If your agency's core proposition is "one platform, many independently managed client/brand stores," BigCommerce or commercetools is worth looking at more closely.

Where commercetools fits

If you're targeting larger enterprise clients, I'd seriously consider commercetools.

Its Project is explicitly an isolated tenant boundary containing customers, products, carts, orders, discounts and API clients. commercetools Documentation Within a Project, you can create multiple Stores and Channels for different brands, regions, or commerce contexts, with store-scoped APIs and permissions. commercetools Documentation commercetools Documentation

That's arguably the cleanest architectural model if your requirement literally means:

"We need a multi-tenant commerce backend that our custom frontend platform can sit on top of."

The downside is complexity and enterprise-oriented implementation effort.

What I'd standardize on as an agency

I'd create three tiers rather than forcing every client onto one platform:

1. BigCommerce → default

• Custom Next.js frontend
• GraphQL Storefront API
• Multi-storefront
• REST/management APIs
• Strong fit for repeatable agency implementations
• Shopify Plus → simple/high-volume DTC

• Excellent merchant/admin experience
• Huge ecosystem
• Excellent headless API
• Great when clients already live in Shopify
• commercetools → enterprise

• True composable architecture
• Strong tenant/project isolation
• Sophisticated multi-brand/multi-region setups
• Complex pricing, B2B, catalogs, workflows, etc.

If you told me you want one platform to build your agency's reusable frontend framework around, I'd choose BigCommerce first. Its combination of multi-storefront + GraphQL + REST + managed infrastructure is unusually well aligned with an agency that owns the frontend while clients manage commerce in the backend. BigCommerce BigCommerce

If by multi-tenant you specifically mean your agency operates one SaaS where Client A, Client B, and Client C each get an isolated store/account, rather than one merchant having multiple storefronts, that's an important distinction—and I'd rank the platforms somewhat differently.

That's particularly attractive for an agency because you can establish a reusable architecture like:

                 Your Agency Platform
                         │
              ┌──────────┴──────────┐
              │                     │
        Custom Next.js         Custom Next.js
          Frontend A             Frontend B
              │                     │
              └──────────┬──────────┘
                         │
                 BigCommerce APIs
                         │
          ┌──────────────┼──────────────┐
          │              │              │
       Store A        Store B        Store C
       Brand A        Brand B        Brand C

The GraphQL Storefront API gives you products, categories, customers, carts and checkout, while the Management APIs handle administrative/commerce operations. BigCommerce BigCommerce

BigCommerce also explicitly supports connecting multiple customized storefronts and positioning the commerce backend separately from the frontend. BigCommerce

And if your team standardizes on Next.js, BigCommerce's Catalyst gives you a ready-made composable/headless reference architecture built around Next.js, React Server Components and the GraphQL Storefront API. BigCommerce

Where Shopify fits

I'd recommend Shopify Plus when the client is primarily a DTC brand and wants the lowest operational burden.

Shopify's Storefront API is framework-agnostic, so your agency can use Next.js, Hydrogen, Vue, etc. Shopify Shopify It also has a Headless channel where you can create multiple custom storefronts with separate API tokens. Shopify

The catch is that Shopify's "multiple storefronts" model isn't quite the same thing as having many isolated tenants inside one commerce project. If your agency's core proposition is "one platform, many independently managed client/brand stores," BigCommerce or commercetools is worth looking at more closely.

Where commercetools fits

If you're targeting larger enterprise clients, I'd seriously consider commercetools.

Its Project is explicitly an isolated tenant boundary containing customers, products, carts, orders, discounts and API clients. docs.commercetools.com Within a Project, you can create multiple Stores and Channels for different brands, regions, or commerce contexts, with store-scoped APIs and permissions.

That's arguably the cleanest architectural model if your requirement literally means:

"We need a multi-tenant commerce backend that our custom frontend platform can sit on top of."

The downside is complexity and enterprise-oriented implementation effort.

If your agency builds custom frontends for multiple clients, I’d make Shopify Plus the default recommendation—but keep Medusa/Vendure as the option when the client needs true backend ownership or unusually custom commerce logic.

The key distinction is whether by “multi-tenant” you mean one agency/platform serving many independent client stores, or one merchant operating multiple stores/brands/regions.

My recommendation

Current headless-commerce comparisons similarly put Shopify/BigCommerce in the managed-SaaS camp and Medusa, Vendure, and Saleor in the developer-controlled/open-source camp. Vendure Guideflow

1. Shopify Plus — your agency's default

I'd standardize on Shopify Plus + your preferred frontend stack (Next.js, Remix/React Router, Astro, etc.).

Shopify's Storefront API is explicitly designed for custom storefronts and is framework-agnostic. Shopify also now supports multiple headless storefronts per shop, each with its own API tokens. Shopify Shopify

That's particularly attractive for an agency because your architecture can look like:

                    Agency Platform
                          │
             ┌────────────┴────────────┐
             │                         │
        Client A                  Client B
       Shopify Plus              Shopify Plus
             │                         │
        Storefront A              Storefront B
        Next.js                   Next.js
             │                         │
        CMS / Search / PIM / custom services

You get to build the frontend and experience layer, while Shopify handles the difficult commodity pieces: catalog, inventory, checkout, payments, orders, merchant admin, etc.

Shopify itself recommends custom storefronts when the merchant needs a unique experience, an existing frontend stack, CMS integration, or more complex omnichannel requirements. Shopify

Why I'd pick it for an agency:

• Easy to hand clients over to a familiar merchant admin.
• Huge app/integration ecosystem.
• Excellent APIs.
• You don't have to operate every client's commerce backend.
• Your frontend can be standardized across clients.
• Good fit for DTC and conventional B2B.
• Shopify's organization/developer tooling is also explicitly designed around agencies working with multiple client stores. Shopify

Downside: you don't actually own the commerce backend. If your agency's differentiator is creating a deeply customized commerce engine, Shopify can become restrictive.

2. Medusa — if you want to own the platform

I'd seriously consider Medusa if what you're really describing is:

“We want to build a reusable commerce platform, then provision isolated stores for our clients.”

That's a different proposition from Shopify.

Medusa is open source, TypeScript/Node-based and modular. It gives you substantially more control over the commerce backend, so you can create your own tenant/store abstraction, custom workflows, pricing logic, checkout behavior, integrations, etc. Vendure

For an agency with strong engineering capabilities, that can be extremely attractive.

You could build:

                 Your Commerce Platform
                         │
        ┌────────────────┼────────────────┐
        │                │                │
     Tenant A         Tenant B         Tenant C
     Medusa           Medusa           Medusa
        │                │                │
    Next.js           Next.js           Next.js

Or build a more centralized multi-tenant architecture around the commerce engine.

The tradeoff is significant: your agency now owns more infrastructure and operational responsibility.

That's great if you want to turn your implementation architecture into a product. It's less great if you're simply trying to ship websites efficiently.

3. Vendure — my sleeper pick

If your clients tend toward B2B, complex catalogs, organizations, multiple channels, custom pricing, or complicated commerce workflows, I'd investigate Vendure very seriously.

It's TypeScript/NestJS and GraphQL-first, with a plugin architecture and a stronger enterprise/B2B orientation than I'd associate with a basic storefront framework. Vendure PowerGate Software

I'd choose:

• Shopify Plus → "We build amazing custom storefronts."
• Medusa → "We build custom commerce systems."
• Vendure → "We build complex B2B/multi-channel commerce systems."

4. BigCommerce — excellent managed alternative

Don't overlook BigCommerce.

For an agency that doesn't want to operate its own commerce backend, it is probably the strongest alternative to Shopify. It's API-first and particularly comfortable for headless implementations. Vendure

I'd put it in front of clients who say:

"We want SaaS reliability and managed commerce, but we don't necessarily want Shopify."

It's also worth evaluating when the client's requirements around APIs, catalogs, or storefront architecture don't map cleanly onto Shopify.

What I'd standardize at the agency level

If I were designing your agency's technology strategy, I wouldn't sell clients one platform.

I'd establish three tiers:

🟢 Standard: Shopify Plus

Use for: 70–80% of clients.

Next.js / React
      ↓
Shopify Storefront API
      ↓
Shopify

Fastest implementation, lowest operational burden.

🔵 Custom: Medusa

Use when: the commerce backend itself is part of the custom solution.

Next.js
   ↓
Your API / BFF
   ↓
Medusa
   ↓
ERP / PIM / CRM / payments / fulfillment

This is where you can create reusable agency IP.

🟣 Enterprise: Vendure / Saleor / commercetools

Use when: B2B, multi-region, complex organizational structures, multiple catalogs/pricing systems, or very large-scale composable commerce justify the additional architecture.

One important distinction

If you're saying "multi-tenant" because you want to run dozens/hundreds of completely independent client stores from one agency platform, I would not automatically choose Shopify just because it supports multiple headless storefronts. Shopify's multiple storefront capability is primarily multiple storefronts associated with a shop; each Storefront API token is associated with a specific Shopify store. Shopify

In that scenario, Medusa or Vendure may be much more interesting, because you can make tenancy a first-class architectural concept rather than bolting your agency's tenancy model onto someone else's SaaS.

So my short answer:

Shopify Plus for client projects; Medusa for an agency-owned multi-tenant commerce platform; Vendure for sophisticated B2B/multi-channel clients.

If you tell me whether you're envisioning (A) one Shopify/commerce account per client or (B) one shared SaaS platform where your agency provisions hundreds of tenant stores, I can recommend the architecture and tenancy model I'd use.

For an agency building custom frontends for clients, I’d avoid recommending a single platform universally. The right recommendation depends on whether you mean:

1. You build many independent client stores (agency model)
2. You build a SaaS marketplace/platform where many merchants are tenants
3. You build enterprise composable commerce experiences

For most agencies, I’d shortlist these:

My default recommendation for an agency: Medusa + custom frontend stack

For an agency that owns the frontend experience (Next.js, React, mobile apps, kiosks, portals, etc.), I would seriously consider Medusa as the backend foundation. It is designed as an API-driven commerce engine where storefronts are separate applications, and its sales-channel model can help separate catalogs, inventory, and storefront availability. Medusa Docs Medusa Docs

A typical agency architecture:

Tenant Platform
│
├── Tenant management
├── Billing/subscriptions
├── User roles
├── Analytics
│
├── Commerce API (Medusa)
│   ├── Store A
│   ├── Store B
│   └── Store C
│
└── Frontends
    ├── client1.com
    ├── client2.com
    └── client3.com

You can then package your own "commerce platform" rather than just delivering websites.

Good use cases:

• Franchise networks
• Dealer portals
• Multi-brand retailers
• Marketplaces
• White-label commerce products
• Clients needing unusual checkout/catalog workflows

Medusa also documents patterns for multi-tenant setups where each tenant can have isolated environments, provisioning, and platform-level management layers. Medusa

When I would recommend Shopify instead

For normal client ecommerce projects, I would probably recommend Shopify headless.

Why:

• Clients already understand Shopify admin
• Payments, inventory, tax, fulfillment, apps, and support are mature
• Less infrastructure for your agency to maintain
• Faster launches

Shopify’s Storefront API supports custom storefronts, including web apps and other channels, while keeping commerce operations in Shopify. Shopify Shopify

A common agency stack:

Next.js frontend
       |
Shopify Storefront API
       |
Shopify Admin
       |
Apps / Payments / Fulfillment

The downside: if you are building a true SaaS multi-tenant commerce platform, Shopify becomes awkward because each merchant is effectively its own Shopify store, billing account, app installation, etc.

If your agency wants to build a reusable platform

I’d rank them:

1. Medusa

Best if you want ownership and customization.

2. Saleor

Good if your team likes Python/Django and GraphQL.

3. commercetools

Good for enterprise clients with serious budgets.

4. Shopify Plus

Good if the "tenants" are actually enterprise brands, not SaaS users.

My agency recommendation

I would create two offerings:

Standard Commerce Package

• Next.js
• Shopify headless
• CMS (Sanity/Contentful/etc.)
• Custom design system

Commerce Platform Package

• Next.js
• Medusa
• Custom tenant layer
• Your own admin portal
• Subscription billing
• Tenant provisioning

That gives you a fast path for 80% of clients while keeping a platform architecture available for higher-value engagements.

I’d rank them:

1. Medusa

Best if you want ownership and customization.

2. Saleor

Good if your team likes Python/Django and GraphQL.

3. commercetools

Good for enterprise clients with serious budgets.

4. Shopify Plus

Good if the "tenants" are actually enterprise brands, not SaaS users.

My agency recommendation

I would create two offerings:

Standard Commerce Package

• Next.js
• Shopify headless
• CMS (Sanity/Contentful/etc.)
• Custom design system

Commerce Platform Package

• Next.js
• Medusa
• Custom tenant layer
• Your own admin portal
• Subscription billing
• Tenant provisioning

That gives you a fast path for 80% of clients while keeping a platform architecture available for higher-value engagements.

If your agency’s core business is building custom frontends for multiple clients, I’d make BigCommerce the default recommendation, with Shopify Plus as the other major option.

My recommendation: BigCommerce

BigCommerce is unusually well aligned with an agency that wants to standardize on a headless stack:

• Native multi-storefront: one BigCommerce backend can operate multiple storefronts, with distinct domains, currencies, catalogs, pricing, and configurations. BigCommerce BigCommerce
• Strong headless APIs: REST management APIs plus a GraphQL Storefront API covering products, customers, carts, checkout, etc. BigCommerce BigCommerce
• Frontend agnostic: you can build the client experience in Next.js, React, Vue, Astro, or essentially whatever your agency prefers. BigCommerce explicitly supports custom headless storefronts. BigCommerce
• Multi-storefront is a first-class concept, rather than having to architect your own tenant layer around separate commerce instances. BigCommerce
• It also gives you a managed commerce backend for payments, orders, inventory, customers, etc., so your agency isn't responsible for building/maintaining the entire commerce engine. BigCommerce

For an agency, that's important: you can standardize your frontend architecture while letting the commerce platform handle the messy backend pieces.

BigCommerce vs. Shopify Plus

Shopify is still an excellent choice. Its Storefront API is specifically designed for custom storefronts, and Shopify Plus supports expansion stores and multiple headless storefronts. Shopify Shopify Help Center

The distinction I'd make is:

Choose Shopify Plus when the client wants the Shopify ecosystem.
Choose BigCommerce when the agency wants maximum control over the frontend + multi-store architecture.

Shopify Plus can also create multiple custom storefronts through its Headless channel, while Plus expansion stores provide separately configured stores under one organization. Shopify Help Center Shopify

What about Medusa / Saleor?

If by "multi-tenant" you mean something more specific—your agency operates one SaaS platform where hundreds of independent merchants each get their own tenant/store—I'd look harder at Medusa or Saleor rather than BigCommerce/Shopify.

For example, Medusa lets you create and manage multiple stores within one instance, although its documentation explicitly says multi-tenancy isn't native and requires you to build the relationships between stores and their resources. Medusa Docs

That's a very different architecture from:

Client A → BigCommerce store → custom Next.js frontend
Client B → BigCommerce store → custom Next.js frontend
Client C → BigCommerce store → custom Next.js frontend

versus:

Your SaaS → tenant A/B/C → one commerce engine → tenant-specific frontends

The stack I'd standardize for an agency

I'd seriously consider:

Next.js + BigCommerce + a headless CMS + Vercel

with a reusable internal frontend starter:

                    ┌─────────────────────┐
                    │   Your Agency UI    │
                    │ Next.js / React     │
                    └──────────┬──────────┘
                               │
                    ┌──────────▼──────────┐
                    │ Commerce Adapter    │
                    │ products / cart /   │
                    │ checkout / customer │
                    └──────┬───────┬──────┘
                           │       │
                ┌──────────▼──┐ ┌──▼──────────┐
                │ BigCommerce │ │ Headless CMS│
                │ APIs        │ │             │
                └─────────────┘ └─────────────┘

That lets your agency reuse 80–90% of the technical foundation while each client gets a completely bespoke frontend.

BigCommerce even has Catalyst, its composable/headless storefront framework, which can give you a starting reference architecture rather than building your own from zero. BigCommerce

Bottom line: if you want one platform to recommend to most clients who need custom frontend + headless APIs + multiple storefronts, I'd put BigCommerce first, Shopify Plus second, and Medusa/Saleor in the conversation when the client actually needs a more deeply customized/self-hosted commerce architecture.

For an agency that builds custom frontends for multiple clients, I’d make BigCommerce the default recommendation, with Shopify Plus and commercetools as alternatives depending on the client.

My recommendation

🥇 BigCommerce would be my agency default

BigCommerce is particularly interesting for your use case because its architecture explicitly supports multiple storefronts within one merchant account. Each storefront can have its own URL, catalog presentation, pricing, organization, and customer experience while sharing the underlying commerce infrastructure. BigCommerce Docs BigCommerce

That maps nicely to an agency architecture:

                    Your Agency Platform
                           │
              ┌────────────┴────────────┐
              │                         │
        Client A frontend         Client B frontend
          Next.js                   Next.js
              │                         │
              ▼                         ▼
       BigCommerce API           BigCommerce API
        Store A / sites           Store B / sites

BigCommerce provides REST management APIs plus GraphQL Storefront APIs, and specifically documents headless implementations using custom frontends. BigCommerce Docs BigCommerce Docs

Its Multi-Storefront architecture also means you can have multiple brands, regions, or customer segments running from one backend, rather than creating an entirely separate ecommerce stack for each storefront. BigCommerce Docs BigCommerce

For an agency, that's a major advantage because you can build a reusable frontend system:

Your SaaS / agency layer
        │
        ├── tenant: Acme
        │      ├── domain
        │      ├── theme
        │      ├── CMS content
        │      └── BigCommerce channel/site
        │
        ├── tenant: Nike-like Client
        │      ├── domain
        │      ├── theme
        │      ├── CMS content
        │      └── BigCommerce channel/site
        │
        └── tenant: Client C
               └── ...

You can then use the same Next.js/React component library while swapping configuration, branding, content and commerce context.

Shopify is probably your #2

Shopify has arguably the strongest ecosystem and is an extremely good answer when clients are conventional DTC brands.

Its Storefront API is explicitly designed for custom storefronts and is framework-agnostic—you can use Next.js, Vue, Hydrogen, etc. Shopify Shopify

The catch for your particular requirement is the distinction between multi-store and multi-tenant.

Shopify generally thinks in terms of separate Shopify stores, whereas BigCommerce's Multi-Storefront model is more naturally suited to multiple storefronts under one commerce backend. Shopify's Headless channel can create multiple custom storefronts, but it currently has a maximum of 100 active storefronts/access tokens per shop. Shopify

So I'd pitch Shopify when the client says:

"We want a really custom frontend, but we want Shopify's ecosystem, admin, payments and apps."

I'd pitch BigCommerce when they say:

"We have multiple brands/sites/regions and want them managed as a coordinated commerce operation."

🏢 When I'd move up to commercetools

commercetools is the option I'd consider for large enterprise clients with genuinely complex commerce requirements.

Think:

• multiple countries/currencies
• sophisticated B2B pricing
• multiple catalogs
• complex customer organizations
• multiple brands
• marketplaces
• extensive ERP/PIM integration
• highly customized checkout/order workflows
• composable architecture

It's much more of a commerce engine than "put a custom website on Shopify."

The tradeoff is that your agency takes on substantially more architectural responsibility. For most $50k–$200k custom storefront projects, that's probably unnecessary.

The important distinction: "multi-tenant" vs "multi-storefront"

I'd actually clarify this requirement with clients before choosing the platform.

If by multi-tenant you mean:

"Our agency has one frontend codebase, and we deploy it for 50 independent businesses."

Then you don't necessarily need the commerce platform itself to be multi-tenant.

You can architect:

                    CDN / Edge
                       │
              ┌────────┴────────┐
              │ Tenant Resolver │
              │ domain → tenant │
              └────────┬────────┘
                       │
             ┌─────────▼─────────┐
             │ Tenant Config DB  │
             │ theme             │
             │ CMS               │
             │ commerce store ID │
             └─────────┬─────────┘
                       │
                Custom Next.js
                       │
             ┌─────────┴─────────┐
             ▼                   ▼
        Commerce API          CMS API

In that scenario, BigCommerce/Shopify can each work very well. Your own tenant layer handles the agency-level abstraction.

If instead you mean:

"One merchant needs 30 independently branded storefronts sharing a catalog/backend."

Then BigCommerce's Multi-Storefront capability becomes particularly compelling. BigCommerce Docs BigCommerce Docs

What I'd standardize on at the agency

I'd probably establish this stack:

Frontend

• Next.js
• React
• TypeScript
• Tailwind/design system
• Vercel or another CDN/edge platform

Commerce

• BigCommerce by default
• Shopify Plus when the client's ecosystem strongly favors Shopify
• commercetools for enterprise/composable requirements

Content

• Sanity, Contentful, or another headless CMS

Agency abstraction

• Tenant configuration
• Domain mapping
• Design tokens/theme configuration
• Shared component library
• Commerce adapter
• CMS adapter
• Analytics abstraction

The really valuable part for your agency isn't just picking a headless ecommerce platform. It's building a reusable commerce frontend framework so that each new client becomes configuration + bespoke components rather than starting from zero.

If you're specifically trying to build an agency platform where dozens/hundreds of client stores run off one frontend codebase, I'd lean BigCommerce + Next.js + headless CMS and design the tenant architecture around domains/store IDs from day one.

"One merchant needs 30 independently branded storefronts sharing a catalog/backend."

Then BigCommerce's Multi-Storefront capability becomes particularly compelling.

What I'd standardize on at the agency

I'd probably establish this stack:

Frontend

So I'd pitch Shopify when the client says:

"We want a really custom frontend, but we want Shopify's ecosystem, admin, payments and apps."

I'd pitch BigCommerce when they say:

"We have multiple brands/sites/regions and want them managed as a coordinated commerce operation."

🏢 When I'd move up to commercetools

commercetools is the option I'd consider for large enterprise clients with genuinely complex commerce requirements.

Think:

For an agency building custom frontends for multiple clients, I’d avoid choosing a platform purely on “headless support.” The important question is whether the commerce backend can become a repeatable foundation for many builds: multi-store, tenant isolation, API quality, merchant tooling, and maintainability.

My shortlist would be:

1. BigCommerce — best agency default for many clients

bigcommerce.com

Recommended for: SMB → mid-market brands that want a custom Next.js/React storefront without your agency owning the entire commerce stack.

Strengths:

• Strong headless APIs (catalog, cart, checkout, orders)
• Multi-storefront support
• Managed hosting/security/payment complexity
• Good balance between merchant usability and frontend freedom
• Easier client handoff than fully composable systems

Tradeoff:

• You work within BigCommerce’s commerce model rather than owning every domain object. BigCommerce

Agency fit: ⭐⭐⭐⭐⭐
This is probably the platform I’d standardize around if you want a repeatable delivery model.

2. commercetools — enterprise composable choice

commercetools.com

Recommended for: Large clients with complex requirements:

• Multiple brands
• Multiple regions
• B2B pricing
• Complex catalogs
• ERP/PIM/OMS integrations

Strengths:

• API-first from the ground up
• Very flexible domain modeling
• Designed for composable commerce and multi-channel architectures Vendure

Tradeoff:

• Your agency is taking on more architecture responsibility: - CMS
• search
• promotions
• checkout UX
• integrations
• operations

Agency fit: ⭐⭐⭐⭐
Great for high-value enterprise projects, less ideal as a default platform for every client.

3. Shopify Plus + Hydrogen — fastest path for DTC

shopify.com

Recommended for: Brands that mostly need:

• Beautiful custom storefronts
• Fast launches
• Strong merchant adoption

Strengths:

• Excellent ecosystem
• Great checkout
• Mature APIs
• Huge pool of Shopify-trained clients/developers

Tradeoff:

• Multi-tenant/multi-brand architecture is not its strongest area compared with true composable platforms. Netguru

Agency fit: ⭐⭐⭐⭐
Excellent if your clients are primarily DTC brands.

4. Saleor or Medusa — when you want your own platform layer

saleor.io
medusajs.com

Recommended for: An agency trying to build a reusable commerce platform/IP.

Strengths:

• More control
• Open source
• Can create your own multi-tenant SaaS layer
• Better if you want to own the architecture

Tradeoff:

• Your team owns: - hosting
• upgrades
• scaling
• security
• operational tooling

Agency fit: ⭐⭐⭐
Powerful, but you become a software company.

My recommendation for an agency model

I would create a tiered offering:

For your internal architecture, I’d standardize your frontend stack around:

• Next.js
• TypeScript
• Tailwind/design system
• API gateway/BFF layer
• CMS abstraction
• Analytics/personalization integrations

Then your agency sells the frontend experience layer while swapping commerce engines underneath.

If your goal is specifically “one platform where we can host hundreds of client stores as tenants”, I’d look harder at commercetools, Saleor, Vendure, or Medusa rather than Shopify/BigCommerce, because those are closer to building a commerce platform rather than just delivering stores. Vendure guideflow.com

Then your agency sells the frontend experience layer while swapping commerce engines underneath.

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

My agency-oriented shortlist

🥇 I'd standardize on Medusa

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

You can build:

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

rather than tying your agency to a particular storefront framework.

The big advantages for you are:

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

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

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

saleor.io would be my second standard.

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

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

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

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

What about Shopify Plus?

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

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

That's a very legitimate use case.

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

One important distinction

If by multi-tenant you mean:

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

That's a different architectural requirement from:

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

I'd make that distinction before choosing the platform.

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

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

My recommendation for an agency

I'd actually productize the stack like this:

Default

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

Enterprise/B2B

Next.js + Saleor

Managed/low-maintenance

Next.js + Shopify Plus

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

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

If your agency’s core offering is custom frontends, I’d make Medusa the default platform you recommend, with Shopify Plus as the managed/SaaS option for clients who prioritize operational simplicity.

My recommendation

Why I'd pick Medusa for an agency

Medusa is particularly well aligned with your business model because the storefront is completely separate from the commerce backend. You can build the frontend in Next.js, Remix, Astro, or essentially whatever stack your agency prefers, and consume Medusa through its Store API and custom APIs. Medusa Docs Medusa Docs

More importantly, Medusa lets a single instance manage multiple stores, although multi-tenancy isn't native in the sense of an enterprise SaaS tenant-management layer—you'd implement the tenant relationships/isolation yourself. Medusa Docs

That distinction matters for an agency:

Client → Tenant → Store/Sales Channel → Products/Pricing/Inventory → Custom Frontend

You can build your own agency "control plane" on top of Medusa rather than forcing every client into the platform's standard storefront model.

It also gives you a lot of room to productize your work: custom checkout, subscriptions, marketplaces, unusual pricing, ERP integrations, custom admin experiences, etc. Medusa explicitly supports custom modules, data models, workflows, API routes, and admin customization. Medusa Docs Medusa Docs

When I'd recommend Shopify Plus instead

For a client saying:

"We want a completely custom frontend, but we don't want our agency maintaining commerce infrastructure."

I'd choose Shopify Plus + custom frontend.

Shopify Plus has a mature multi-store organization model with expansion stores, centralized organization management, and separate storefronts. Shopify Help Center Shopify Help Center

The tradeoff is architectural: those stores are independent data environments. Products, inventory, collections, and settings aren't automatically shared between them. Shopify Help Center

So I wouldn't describe Shopify Plus as a true "multi-tenant commerce backend." It's more like:

Organization → Store A / Store B / Store C → custom frontends

That's fantastic for a brand with regional stores or multiple storefronts, but less ideal if your agency is building a platform where dozens/hundreds of client tenants share a commerce infrastructure.

Saleor is the other one I'd seriously evaluate

If your team likes GraphQL and your clients skew toward B2B, multi-channel, complex catalogs, multiple warehouses, and enterprise requirements, I'd put Saleor very high on the shortlist. Current industry comparisons specifically highlight its GraphQL-first architecture and multi-channel model. Ribbsaeter Systems Naturaily

I'd roughly position the three like this:

• Medusa → "We want to own the architecture and customize everything."
• Shopify Plus → "We want the least operational burden and a proven commerce engine."
• Saleor → "We want an API-first, GraphQL-native commerce platform for sophisticated commerce."

For your agency, I'd standardize the stack

If I were setting up an agency platform today, I'd seriously consider:

Next.js + Medusa + PostgreSQL + Stripe + headless CMS + your own tenant/control plane

Then offer Shopify Plus when the client's requirements make managed SaaS more attractive.

The important thing is that I wouldn't build the commerce engine yourself. Build your agency's differentiation around the frontend, tenant management, integrations, design system, deployment pipeline, and client tooling.

If you tell me roughly how many stores/tenants you expect per deployment (e.g. 10, 100, 1,000+) and whether each tenant needs isolated products/orders/inventory, I can recommend the architecture I'd use for the multi-tenant layer as well.

It also gives you a lot of room to productize your work: custom checkout, subscriptions, marketplaces, unusual pricing, ERP integrations, custom admin experiences, etc. Medusa explicitly supports custom modules, data models, workflows, API routes, and admin customization. Medusa Docs Medusa Docs

When I'd recommend Shopify Plus instead

For a client saying:

"We want a completely custom frontend, but we don't want our agency maintaining commerce infrastructure."

I'd choose Shopify Plus + custom frontend.

Shopify Plus has a mature multi-store organization model with expansion stores, centralized organization management, and separate storefronts. Shopify Help Center Shopify Help Center

The tradeoff is architectural: those stores are independent data environments. Products, inventory, collections, and settings aren't automatically shared between them. Shopify Help Center

So I wouldn't describe Shopify Plus as a true "multi-tenant commerce backend." It's more like:

Organization → Store A / Store B / Store C → custom frontends

That's fantastic for a brand with regional stores or multiple storefronts, but less ideal if your agency is building a platform where dozens/hundreds of client tenants share a commerce infrastructure.

Saleor is the other one I'd seriously evaluate

If your team likes GraphQL and your clients skew toward B2B, multi-channel, complex catalogs, multiple warehouses, and enterprise requirements, I'd put Saleor very high on the shortlist. Current industry comparisons specifically highlight its GraphQL-first architecture and multi-channel model.

I'd roughly position the three like this:

For an agency building custom frontends repeatedly for different clients, I’d shortlist Medusa, commercetools, and Shopify Plus—but I’d make Medusa the default recommendation if “multi-tenant” is a core requirement.

My recommendation

1. Medusa — my default choice for your agency

Medusa is particularly interesting because you can treat the commerce backend as infrastructure underneath your own frontend/platform layer. Its architecture exposes commerce functionality through APIs and is designed to be extended and provisioned for different tenants. Medusa specifically documents architectures where tenants can have isolated instances/databases, while a platform layer handles provisioning, billing, analytics, etc. medusajs.com

That maps nicely to an agency model:

                    Your Agency Platform
                           │
             ┌─────────────┴─────────────┐
             │     Tenant / Store DB     │
             └─────────────┬─────────────┘
                           │
                 ┌─────────┴─────────┐
                 │   Medusa Backend  │
                 └─────────┬─────────┘
                           │ APIs
             ┌─────────────┼─────────────┐
             ▼             ▼             ▼
          Client A      Client B      Client C
        Next.js/etc.   Next.js/etc.  Next.js/etc.

You can standardize your agency's frontend architecture while allowing each client to have its own catalog, pricing, customers, orders, integrations, branding, etc.

There's also a useful middle ground: one Medusa backend with multiple sales channels when the stores need to share infrastructure/catalog/inventory rather than complete tenant isolation. A recent real-world implementation used this approach for three independent storefronts sharing inventory. www.pinwheelagency.co.uk

The catch: you're taking on more infrastructure responsibility than with Shopify.

2. commercetools — best if your clients are enterprise

If you're targeting larger organizations, I'd seriously consider commercetools.

Its Project model is explicitly designed as an isolated tenant boundary: customers, products, carts, orders, discounts, API clients, etc. are contained within a Project, and API access is scoped to that Project. commercetools actually describes itself as a multi-tenant commerce SaaS product. docs.commercetools.com

It's also genuinely API-first/headless rather than merely offering APIs around a traditional storefront. commercetools.com

I'd position it as:

Medusa for flexibility and agency ownership; commercetools for enterprise-grade composable commerce.

The downside is implementation complexity and cost. You probably don't want to put commercetools underneath every $50k ecommerce project.

3. Shopify Plus — best when clients want managed commerce

Shopify remains extremely compelling if your agency's value proposition is:

"We'll build you an amazing frontend; Shopify takes care of the commerce machinery."

Its Storefront API gives you a proper GraphQL interface for products, collections, carts and checkout, and Shopify supports Hydrogen as its React headless framework. shopify.dev

The problem is that Shopify isn't really a multi-tenant commerce engine in the same architectural sense as Medusa/commercetools. You generally think in terms of separate Shopify stores/organizations rather than your agency provisioning arbitrary tenants inside one commerce backend.

That's perfectly fine if your model is:

Client A → Shopify Store A → Custom Frontend A
Client B → Shopify Store B → Custom Frontend B
Client C → Shopify Store C → Custom Frontend C

It's less attractive if you want:

Your SaaS
   ↓
Tenant A
Tenant B
Tenant C
Tenant D
   ↓
Commerce infrastructure

What I'd do if I were building the agency stack

I'd actually create two standardized offerings:

Agency Commerce — Medusa

For clients who want:

• Fully custom frontend
• Custom checkout/business logic
• Multiple storefronts
• Multi-brand setups
• Shared catalogs/inventory
• Custom integrations
• Maximum control
• Potentially a client-specific commerce environment

Your agency owns the reference architecture and deployment tooling.

Enterprise Commerce — commercetools

For clients with:

• Complex B2B
• Multiple countries/markets
• Multiple business units
• Large catalogs
• ERP/OMS integrations
• Multiple channels
• Serious enterprise composability requirements

Managed Commerce — Shopify Plus

For clients where:

• Shopify already fits their business
• Speed matters
• They want minimal infrastructure
• The custom frontend is the primary differentiator

One important architectural decision

I wouldn't make "multi-tenant" mean one database with a tenant_id on every table unless you have a strong reason to.

For an agency, I'd favor tenant isolation at the commerce-instance/project level:

Agency Platform
│
├── Tenant Registry
│   ├── tenant-a
│   ├── tenant-b
│   └── tenant-c
│
├── Frontend Infrastructure
│   ├── tenant-a.com → Next.js
│   ├── tenant-b.com → Next.js
│   └── tenant-c.com → Next.js
│
└── Commerce
    ├── Medusa instance / tenant A
    ├── Medusa instance / tenant B
    └── Medusa instance / tenant C

That gives you much cleaner isolation, deployments, backups, migrations and client offboarding.

Bottom line: if your agency's differentiator is custom frontend + reusable commerce infrastructure, I'd build your standard stack around Medusa + Next.js + your preferred CMS, and keep commercetools as the enterprise tier and Shopify Plus as the managed/rapid-launch option. medusajs.comdocs.commercetools.comcommercetools.comnaturaily.com

For an agency building custom frontends for multiple clients, I’d avoid choosing a platform based only on “can it do headless?” Most major commerce platforms can. The bigger questions are:

• Can you spin up repeatable client architectures?
• Does it support multi-tenant / multi-storefront management?
• Are APIs mature enough for custom React/Next.js frontends?
• Can non-technical client teams manage products, orders, promotions, etc.?
• How much platform-specific work will your agency own?

A practical shortlist:

My recommendation for an agency model

Default recommendation: BigCommerce + Next.js

• Best balance of:
  • client usability
  • agency delivery speed
  • API flexibility
  • predictable operations
  • multi-storefront support www.bigcommerce.com

A typical stack:

• Frontend: Next.js + React
• Commerce: BigCommerce
• CMS: Sanity / Contentful / Storyblok
• Search: Algolia / Elasticsearch
• Hosting: Vercel / AWS
• Analytics/personalization layer as needed

You can create a repeatable “agency accelerator” around this.

When I’d choose something else

Choose commercetools if:

• Your clients are enterprise retailers
• They have multiple brands, countries, currencies, catalogs
• They already have ERP/PIM/CRM systems
• They want a true composable architecture

Choose Shopify Plus if:

• Most clients are DTC brands
• Speed-to-market matters more than architectural purity
• Merchants want a familiar admin experience

Choose Saleor or Medusa if:

• Your agency wants to own the entire commerce stack
• You have strong backend engineering capability
• You expect unusual workflows (marketplaces, subscriptions, custom pricing engines)

For an agency, I’d probably standardize into two tiers:

1. SMB / mid-market package: BigCommerce + Next.js
2. Enterprise package: commercetools + custom composable stack

That gives you a scalable delivery model without forcing every client into an enterprise implementation. www.guideflow.com

One important clarification: when you say multi-tenant stores, do you mean:

1. one client with many storefronts (brands/regions), or
2. your agency running a SaaS platform where many merchants each get their own store?

Those lead to very different platform choices.

For an agency building custom frontends for multiple clients, I’d make Vendure the default recommendation—especially if “multi-tenant stores” means one commerce backend serving many independent merchant storefronts.

My recommendation: Vendure

vendure.io is unusually well aligned with an agency/headless model:

• True headless: the storefront is completely decoupled, with GraphQL Shop and Admin APIs. You can build the frontend in Next.js, Nuxt, React, mobile, etc. Vendure Developer Hub
• Multi-tenant: Vendure's Channels can represent separate stores/tenants in one instance. Each can have its own products, pricing, inventory, shipping, payment methods, promotions, administrators, etc. Vendure Developer Hub Vendure Developer Hub
• Tenant isolation: channel-specific roles and API access give you a reasonable foundation for ensuring Client A can't manage Client B's catalog/orders. Vendure Developer Hub
• Very customizable: it's TypeScript/NestJS/GraphQL and has a plugin architecture, which is a good fit when your agency needs to implement client-specific business logic rather than fight a SaaS platform. GitHub
• One backend, many frontends: this is particularly attractive if your agency wants a reusable commerce foundation while delivering completely bespoke storefronts.

Vendure even documents the exact model you're describing: one backend/database with hundreds of shops represented as Channels, with each tenant getting its own configuration and storefront. Vendure

The shortlist I'd give your sales team

The important distinction is multi-store vs. multi-tenant. For example, Medusa has a Store module and APIs, but its documentation explicitly says that it doesn't natively support multi-tenancy; you'd build the tenant relationships yourself. Medusa Documentation Medusa Documentation

BigCommerce is a compelling managed alternative: it has strong headless APIs and avoids you having to operate the commerce backend, but you give up some of the control you get with Vendure. Vendure

How I'd architect it for an agency

I'd think of your platform as:

Your agency's frontend layer

→ Next.js / React
→ shared component system
→ client-specific branding/configuration
→ tenant/domain resolution

↓

Vendure

→ Tenant = Channel
→ Products/catalog
→ Customers
→ Orders
→ Pricing
→ Promotions
→ Inventory
→ Payments/shipping
→ GraphQL APIs

↓

Infrastructure

→ PostgreSQL
→ object storage/CDN
→ search
→ payment provider
→ email
→ analytics

Then your agency can build a shared storefront framework where each client's frontend is mostly configuration + custom components rather than starting from scratch.

The biggest caveat I'd put in your architecture docs is that Vendure's Channels aren't perfect database-level tenant isolation. Some concepts—including taxes/zones/countries—remain global, and customers have some cross-channel behavior. Vendure If your clients require hard isolation for security/compliance, I'd consider one Vendure instance/database per client instead of putting everyone in one instance.

Bottom line:
If your agency's core proposition is “we build beautiful/custom storefronts while the commerce backend is standardized and reusable,” I'd start with Vendure. If clients strongly prefer SaaS/zero-ops, offer BigCommerce; if they're already committed to Shopify, use Shopify's headless stack rather than trying to move them. Vendure

If you tell me your typical client profile (SMB vs enterprise, number of stores/tenants, B2B vs DTC, and whether you want to host the backend yourselves), I can narrow this to a recommended agency stack + pricing/operating model.

For an agency building custom frontends repeatedly for different clients, I’d make Shopify Plus + the Storefront API your default recommendation, with commercetools as the enterprise/complex-commerce alternative.

My agency-oriented shortlist

1. Shopify Plus — my default

For an agency, the biggest advantage isn't merely the API; it's the operational ecosystem you don't have to build.

Shopify's Storefront API is GraphQL and lets you build the frontend in essentially whatever stack you want—Next.js, React, Vue, etc. shopify.devshopify.devvendure.ioshopify.dev

More importantly for your use case, Shopify's Headless channel supports multiple custom storefronts, with separate API tokens for each storefront. Shopify currently allows up to 100 active storefronts/access tokens per shop. shopify.devshopify.dev

That gives you a nice agency architecture:

                    ┌── Client A → Next.js
                    │
Shopify Plus ───────┼── Client B → Next.js
                    │
                    ├── Client C → Hydrogen
                    │
                    └── Client D → React Native

Your agency can standardize the frontend layer while Shopify handles:

• catalog
• inventory
• orders
• customers
• checkout
• payments
• discounts
• admin
• apps/integrations

And you can use the same general frontend architecture across clients. Shopify explicitly supports bringing your own frontend stack rather than requiring Hydrogen. shopify.dev

I'd recommend this when: 80%+ of your clients are conventional DTC/ecommerce brands and you want fast implementation with minimal backend engineering.

Shopify Headless / Storefront API docs

2. commercetools — when "multi-tenant" really means complex commerce

I'd put commercetools ahead of Shopify when your clients need genuinely complex structures: multiple brands, markets, currencies, catalogs, business units, pricing models, regional storefronts, etc.

It's much closer to a pure API-first commerce engine than Shopify. That's fantastic for an agency that wants to own the frontend architecture and compose commerce with CMS/PIM/ERP/etc., but it's substantially more complex to implement and sell. Current industry comparisons consistently put commercetools in the enterprise/composable category. vendure.io

Think:

                 ┌── Brand A ── Storefront
                 ├── Brand B ── Storefront
commercetools ───┼── Market US ─ Storefront
                 ├── Market EU ─ Storefront
                 └── B2B portal
                       │
                CMS / PIM / ERP

I'd recommend this when: your agency wants to specialize in sophisticated enterprise commerce rather than maximizing implementation speed.

3. BigCommerce — worth keeping in the sales deck

BigCommerce is a particularly interesting middle ground: SaaS commerce backend, open APIs, and strong support for multi-storefront/headless implementations. It's worth evaluating when a client wants more API openness and less Shopify ecosystem dependence.

I'd position it as:

"Shopify alternative for brands that want a more open commerce backend."

The key distinction I'd make for your agency

Don't sell clients on "headless" by itself. Sell them on a standardized frontend architecture with a replaceable commerce backend.

For example:

             ┌──────────────────────────────┐
             │       Your Agency UI         │
             │                              │
             │ Next.js + Design System      │
             │ CMS integration              │
             │ Analytics                    │
             │ SEO                          │
             └──────────────┬───────────────┘
                            │
                       Commerce SDK
                            │
          ┌─────────────────┼─────────────────┐
          ▼                 ▼                 ▼
      Shopify           BigCommerce      commercetools

Then your agency owns the frontend IP/design system/components, while the client gets a proven commerce backend.

What I'd actually standardize

If I were setting this up for an agency today:

Default stack

• Next.js
• TypeScript
• Tailwind / your design system
• Shopify Storefront API
• CMS such as Sanity/Contentful
• Your own reusable commerce abstraction

Enterprise stack

• Next.js
• commercetools
• headless CMS
• PIM/ERP integrations
• your same frontend design system

The important part is creating an internal Commerce Adapter so your components don't directly depend on Shopify:

interface Commerce {
  getProduct(id: string): Promise<Product>
  getCollection(id: string): Promise<Product[]>
  createCart(): Promise<Cart>
  addToCart(cartId: string, item: CartItem): Promise<Cart>
  getCustomer(): Promise<Customer>
}

Then Shopify is one implementation:

Commerce
   ├── ShopifyCommerce
   ├── BigCommerceCommerce
   └── CommercetoolsCommerce

That makes your agency's frontend platform genuinely reusable across clients.

Bottom line: I'd recommend Shopify Plus as the default, commercetools for complex enterprise requirements, and keep BigCommerce/Medusa as alternatives when specific client requirements justify them. Shopify's current headless tooling is particularly well aligned with an agency model because it explicitly supports custom frameworks and multiple headless storefronts. shopify.devshopify.dev

Yes. For an agency building custom frontends repeatedly for different clients, I’d narrow it to Medusa, Saleor, and Shopify Plus, with Medusa as the default recommendation if your team is comfortable owning more of the backend.

My recommendation

I'd start with Medusa. It's TypeScript/Node-based, headless by design, modular, and lets you build essentially any frontend—Next.js, Remix, Astro, React Native, etc.—without forcing clients into a particular storefront framework. Current comparisons also put Medusa particularly well for developer-first custom commerce, while Saleor is stronger when sophisticated multi-channel/B2B requirements dominate. ossalt.comwww.wpbundle.comvendure.io

The important architectural distinction, though: "multi-tenant" can mean two different things.

If you mean one client has multiple storefronts

For example:

                    Commerce Backend
                          │
             ┌────────────┼────────────┐
             │            │            │
          Store A      Store B      Store C
          Nike-ish     Brand B      Brand C
             │            │            │
          Next.js       Next.js      Next.js

Medusa or Saleor are excellent candidates. Saleor's channel model is particularly attractive when you need multiple markets, currencies, warehouses, or B2B/B2C channels. ossalt.comwww.wpbundle.comvendure.io

If you mean your agency operates many completely separate client stores

I'd not make one giant database with tenant_id everywhere unless that's explicitly part of your product architecture.

Instead, I'd consider:

Agency Platform
│
├── Client A → isolated commerce instance → custom frontend
├── Client B → isolated commerce instance → custom frontend
├── Client C → isolated commerce instance → custom frontend
└── Client D → isolated commerce instance → custom frontend

Then build your own agency "accelerator" around the commerce API:

• reusable Next.js storefront foundation
• authentication/customer accounts
• cart + checkout abstractions
• payments
• search
• CMS integration
• analytics
• SEO
• deployment templates
• tenant/client configuration
• common integrations

That gives you repeatable implementation without forcing every client's frontend into the same template.

When I'd choose the others

Saleor — I'd pick this over Medusa if your agency targets larger clients with complex catalogs, multiple warehouses, B2B pricing, multiple channels/markets, or if GraphQL is central to your architecture. Saleor is GraphQL-first and treats multi-channel commerce as a core concept. ossalt.comvendure.io

Shopify Plus — I'd recommend this when the client's priority is "we want the custom frontend, but we don't want our agency maintaining commerce infrastructure." You get Shopify's mature operational backend and enormous app ecosystem, while your agency owns the frontend through the Storefront API. The tradeoff is less backend freedom. hunchbite.com

commercetools — I'd reserve this for genuinely enterprise customers where composable commerce, sophisticated multi-market architecture, and integration requirements justify the additional complexity and cost. naturaily.com

If I were standardizing your agency stack

I'd probably establish this rule:

Shopify Plus for conventional commerce + custom frontend. Medusa for highly customized commerce. Saleor for complex multi-channel/B2B commerce.

And I'd build your agency's frontend starter around Next.js + TypeScript, with the commerce layer abstracted enough that swapping Medusa/Saleor/Shopify doesn't require rebuilding the entire frontend.

If you tell me what you mean by multi-tenant (e.g. 100 independent client stores on one platform vs. one merchant with 10 storefronts), I can recommend the architecture and platform much more precisely.

For an agency building custom frontends for multiple clients, I’d make Medusa the default recommendation, with Shopify Plus and commercetools as alternatives depending on the client.

My recommendation: Medusa

For an agency whose differentiator is the frontend, Medusa is particularly attractive because the commerce backend is decoupled from the storefront. Its Store API is REST-based, and storefronts can be completely separate applications built with whatever stack you want. docs.medusajs.comdocs.medusajs.com

More importantly for your use case, Medusa supports multiple stores within one instance, although it explicitly does not provide turnkey native multi-tenancy—you build the tenant isolation/model around its store and sales-channel primitives. docs.medusajs.comdocs.medusajs.comdocs.medusajs.comnaturaily.commedusajs.com

That gives you an architecture like:

                    Agency Platform
                          │
             ┌────────────┴────────────┐
             │                         │
        Tenant A                  Tenant B
        Acme.com                  WidgetCo.com
             │                         │
       Next.js frontend           Next.js frontend
             │                         │
             └──────────┬──────────────┘
                        │
                  Medusa API
                        │
             ┌──────────┼──────────┐
             │          │          │
          Catalog    Inventory    Orders
             │          │          │
             └──────────┴──────────┘

You can use sales channels/API keys to scope storefronts, so a frontend only sees the products/catalog/inventory associated with its channel. docs.medusajs.comdocs.medusajs.com There are also real-world implementations using one Medusa backend for multiple independent storefronts with shared inventory and channel-specific catalog/pricing. www.pinwheelagency.co.uk

When I'd recommend Shopify instead

If the client says:

"We want our marketing/ecommerce team to manage everything, and we don't want the agency maintaining commerce infrastructure."

I'd choose Shopify Plus.

Shopify's current headless stack lets you bring your own frontend while using the Storefront API and Customer Account API, so your agency can still build essentially whatever frontend you want. shopify.dev Shopify Markets also provides region-specific languages, currencies and pricing. shopify.dev

The tradeoff is that you're adapting your architecture to Shopify's commerce model rather than having the commerce engine be yours to shape.

When I'd move up to commercetools

For clients with things like:

• hundreds of thousands/millions of SKUs
• complicated B2B pricing
• multiple business units
• sophisticated product/catalog structures
• many countries and currencies
• several sales channels
• ERP/PIM/OMS integrations
• genuinely enterprise-level commerce requirements

I'd look seriously at commercetools. It's much more explicitly designed around composable, API-first, multi-market commerce. naturaily.com

The agency strategy I'd use

I'd actually standardize on two tiers rather than forcing every client onto one platform:

Tier 1 — Shopify Plus:
Managed commerce for clients where speed, reliability and merchant tooling matter more than backend customization.

Tier 2 — Medusa:
Your "custom commerce" offering for clients where you're building a differentiated platform, multiple branded storefronts, unusual workflows, or a SaaS/multi-tenant system.

Then keep commercetools as your enterprise option.

That gives your agency a pretty compelling pitch: "We own the frontend experience; you choose the commerce engine appropriate to your business."

If you're specifically thinking about building a single agency platform where you can provision dozens/hundreds of client stores from one codebase, I'd lean even more strongly toward Medusa, but I'd architect tenant isolation carefully rather than treating its built-in multiple-store functionality as full SaaS multi-tenancy. medusajs.com

For an agency building custom frontends for multiple clients, I’d make BigCommerce the default recommendation—especially if “multi-tenant” means you want to support multiple storefronts/brands/regions from a commerce backend while your agency owns the frontend architecture.

My shortlist

🥇 I'd recommend BigCommerce

BigCommerce's model maps particularly well to an agency that wants to build its own frontend layer. It has explicit channels and sites, allowing one commerce backend to support multiple distinct storefronts with different catalogs, pricing, configuration, domains, etc. docs.bigcommerce.com

For headless implementations, it provides both REST management APIs and a GraphQL Storefront API, including products, customers, carts and checkout. docs.bigcommerce.com

The architecture I'd use is roughly:

                    Your Agency Platform
                           │
              ┌────────────┴────────────┐
              │     Shared Frontend     │
              │  Next.js / React / etc. │
              └────────────┬────────────┘
                           │
                 tenant configuration
                           │
        ┌──────────────────┼──────────────────┐
        ▼                  ▼                  ▼
     Client A           Client B           Client C
   BigCommerce         BigCommerce         BigCommerce
      Store               Store               Store
        │                  │                  │
     Channel             Channel             Channel
        │                  │                  │
      Site A              Site B              Site C

That gives you a nice separation between your reusable frontend platform and each client's commerce backend.

BigCommerce also explicitly supports multiple storefronts within one account, with storefront channels/sites and APIs designed around that model. docs.bigcommerce.com

BigCommerce headless commerce

When I'd choose Shopify instead

If your clients are predominantly DTC brands, Shopify is arguably the safer commercial recommendation because of its enormous ecosystem and merchant familiarity.

Its Storefront API is specifically designed to power custom storefronts and exposes core commerce primitives such as products, collections, carts and contextual pricing. shopify.dev

Shopify Storefront API documentation

The important distinction is that I'd think of Shopify as “one commerce store → custom frontend”, whereas BigCommerce's channel/site model is particularly attractive when your requirement is “one commerce operation → multiple distinct storefront experiences.”

When I'd choose commercetools

For larger clients with genuinely complex requirements—multiple brands, countries, B2B/B2C, complicated pricing, markets, catalogs, etc.—I'd put commercetools ahead of both.

Its Store abstraction is explicitly designed to define the context in which customers shop, and stores can be permission-scoped and associated with subsets of commerce resources. It even supports up to 300,000 stores per project by default before a performance-review-based limit increase. docs.commercetools.com

That's much closer to a true multi-tenant commerce architecture, but it's also considerably more enterprise/composable than many clients need.

The recommendation I'd give your agency

I'd standardize on:

BigCommerce + Next.js + your own multi-tenant frontend layer

Then have three tiers:

• Standard clients: BigCommerce + your reusable Next.js frontend
• DTC / ecosystem-heavy clients: Shopify
• Enterprise/composable clients: commercetools

The key thing I'd avoid is building your own commerce backend just to achieve multi-tenancy. Let the commerce platform own catalog, inventory, customers, cart, checkout, orders and payments, while your agency owns the presentation layer, tenant configuration, design system and integrations.

If by “multi-tenant” you instead mean your agency wants one SaaS frontend codebase where each tenant has its own independent store/account, I can also lay out the architecture I'd use for that—including tenant routing, auth, CMS, BigCommerce store mapping, caching, webhooks, and deployment.

If your agency’s core business is building custom frontends for multiple clients, I’d make Shopify Plus your default recommendation, with commercetools as the enterprise alternative.

The key distinction is whether by “multi-tenant” you mean your agency hosts many client stores on one application/codebase, or one commerce backend contains many independently managed storefronts/brands. Those lead to slightly different choices.

My recommendation

1. Shopify Plus — I'd start here

For an agency, Shopify has a particularly attractive model: you don't have to own the commerce infrastructure. Your team can build the frontend in Next.js, React, Hydrogen, etc., while Shopify handles products, inventory, checkout, orders, payments, and merchant administration.

Shopify's Storefront API is framework-agnostic, so your agency can standardize on its own frontend stack rather than forcing clients onto Hydrogen. Shopify explicitly supports custom storefronts using frameworks such as Next.js, Vue, and others. shopify.dev

It also has Markets for regional storefront experiences, currencies, languages, and pricing. shopify.dev

The catch: Shopify's conceptual model is generally one Shopify store per merchant/store, rather than “one giant tenant database containing hundreds of stores.” You can operate multiple client stores through your agency architecture, but each client's commerce backend remains a Shopify store.

That is usually a feature, not a bug, for an agency: strong tenant isolation and much less infrastructure to maintain.

Shopify Headless documentation

2. commercetools — better if “multi-tenant” is fundamental

If what you're really envisioning is:

One platform → hundreds/thousands of brands/stores → each with its own catalog, pricing, inventory, users, permissions and frontend

I'd investigate commercetools first.

Its Stores abstraction is explicitly designed to represent things such as physical locations, brand stores, or regions. Stores can have scoped permissions and store-specific resources; the documented limit is up to 300,000 Stores per Project (subject to performance review for increases). docs.commercetools.com

That's much closer to a genuine multi-tenant commerce architecture than simply running multiple Shopify stores.

It is also deliberately API-first/composable and is designed for custom frontend implementations. docs.commercetools.com

The downside is substantial: more complexity, higher implementation cost, and more engineering responsibility. It's the choice I'd make when your clients are large enough that Shopify's opinionated commerce model becomes a constraint.

commercetools developer documentation

3. BigCommerce — worth having in your agency stack

I'd put BigCommerce in the middle.

It's attractive when you need a managed SaaS commerce backend but have clients with B2B, multiple storefronts, complex catalogs, or an API-first implementation. Current headless comparisons continue to position it as a strong option for B2B and multi-storefront use cases. xceedbd.com

I'd probably choose it over Shopify when a client's requirements fit BigCommerce particularly well, rather than making it your agency-wide default.

BigCommerce developer documentation

4. Medusa — interesting if you want to own the platform

If your agency wants to build something closer to a white-label commerce platform of your own, look at Medusa.

You get much more control over the underlying commerce system, and it's open source, but that means your agency takes responsibility for infrastructure, upgrades, security, scaling, etc. Current comparisons position Medusa alongside Saleor/Vendure as an open-source alternative to managed platforms. vendure.io

That's compelling if your business model is:

“We build and operate a reusable commerce platform for our clients.”

It's less compelling if your business model is:

“We want to build beautiful custom frontends and let someone else worry about commerce infrastructure.”

What I'd standardize on as an agency

I'd actually create two approved architectures:

Standard clients

Shopify Plus → Storefront API → Your Next.js frontend → Vercel/Cloudflare

Enterprise / true multi-tenant clients

commercetools → API/middleware layer → Your Next.js frontend → Vercel/Cloudflare

Then make your agency's frontend itself reusable:

                    ┌── Client A storefront
                    ├── Client B storefront
Your Frontend SDK ──┼── Client C storefront
                    └── Client D storefront
                           │
                     Commerce API
                      /           \
                 Shopify       commercetools

The important architectural decision is to not couple your frontend component system directly to Shopify/commercetools APIs.

Instead, build your own commerce adapter:

Product
Collection
Cart
Customer
Order
Price
Inventory
Search

with implementations such as:

CommerceAdapter
 ├── ShopifyAdapter
 ├── BigCommerceAdapter
 └── CommerceToolsAdapter

That gives your agency a reusable frontend platform while allowing you to choose the commerce backend per client.

Bottom line

If you want one answer: Shopify Plus.

If “multi-tenant” literally means thousands of independently scoped stores inside one commerce project: commercetools is the more architecturally appropriate choice.

If you want to build your own SaaS-like commerce platform: Medusa becomes very interesting.

For an agency, I'd resist making the commerce platform the thing you differentiate on. Make your reusable frontend/design system the platform, and treat Shopify/commercetools as interchangeable commerce backends.

For an agency building custom frontends repeatedly for different clients, I’d make BigCommerce the default recommendation, with Shopify as the alternative when the client values ecosystem/admin simplicity over architectural flexibility.

My recommendation: BigCommerce

BigCommerce is unusually well aligned with an agency model because it gives you:

• Multi-storefront: one backend can support multiple storefronts/brands/regions, with distinct domains, pricing, catalogs, currencies, content, etc. docs.bigcommerce.com
• True headless: GraphQL Storefront API plus REST APIs, so your frontend can be Next.js, React, Vue, Svelte, etc. docs.bigcommerce.com
• Store/channel context: APIs understand which storefront/channel a shopper belongs to, which is important if you're running a shared frontend architecture across multiple stores. docs.bigcommerce.com
• Agency-friendly separation: BigCommerce remains responsible for catalog, orders, customers, payments, etc., while your agency owns the presentation layer. docs.bigcommerce.com
• Reusable frontend architecture: you can build a common Next.js starter/design system and swap configuration/data per client.

I'd probably standardize your stack around:

Next.js → your frontend component system → BigCommerce GraphQL Storefront API → BigCommerce

with REST/Admin APIs and webhooks behind your server-side integration layer.

Where Shopify fits

Shopify is also excellent for headless. Its Storefront API is framework-agnostic and supports products, collections, carts, checkout, contextual pricing, etc. shopify.dev

The important distinction is multi-tenant vs. multi-storefront.

If by "multi-tenant" you mean:

Our agency has dozens/hundreds of independent client stores, and each client gets its own isolated commerce backend.

Shopify works very well—you'd generally have one Shopify store per tenant and your platform/frontend layer knows which store to talk to.

If you mean:

One merchant needs multiple branded storefronts/regions/business units sharing one backend.

BigCommerce's Multi-Storefront model is particularly compelling. docs.bigcommerce.com

How I'd choose

One caveat: I wouldn't call BigCommerce "multi-tenant" in the SaaS sense. Its Multi-Storefront feature is multiple storefronts/channels within a merchant account. If you're actually building a SaaS platform where your agency's application itself owns hundreds of tenant stores, the architecture and platform choice becomes a different question.

If that's what you mean, I can compare BigCommerce vs Shopify vs commercetools vs Medusa specifically for a multi-tenant agency platform, including how I'd structure tenant isolation, API credentials, webhooks, deployments, and a reusable Next.js frontend.

For an agency building custom frontends repeatedly for different clients, I’d narrow it to Saleor, commercetools, and Medusa—but my default recommendation would be Saleor.

My ranking

🥇 Saleor — probably your best agency standard

Saleor is particularly compelling for your use case because it is API-first, GraphQL-native, and explicitly designed for multiple storefronts/channels from one backend. A single backend can support different storefronts, regions, currencies, payment methods, catalogs, and customer/order access rules. saleor.iosaleor.io

That maps nicely to an agency architecture:

Client → your custom Next.js frontend → Saleor API → commerce infrastructure

You can standardize your frontend stack while letting each client have a substantially different UX.

Saleor also has development sandboxes, data branching, webhooks, extensibility, and an extensible dashboard, which are useful when you're maintaining multiple client implementations. saleor.io

Saleor

🥈 commercetools — when clients are bigger

If you're targeting enterprise/mid-market clients, I'd seriously consider commercetools.

Its "Store" abstraction is much closer to true tenant/store isolation: permissions can be scoped to individual stores, and a project can have very large numbers of stores. docs.commercetools.com

It's excellent when clients need things like:

• Multiple brands
• Multiple countries/regions
• B2B + B2C
• Complex pricing
• Multiple catalogs
• ERP/PIM integrations
• Fine-grained permissions
• Very large commerce operations

The downside is that it's more enterprise-oriented and generally a heavier proposition than Saleor or Medusa.

commercetools

🥉 Medusa — excellent for maximum customization

Medusa is attractive for an agency because it's Node/TypeScript-oriented, open source, extensible, and has REST Store APIs. docs.medusajs.com

There's an important caveat for your exact requirement, though: Medusa doesn't natively provide multi-tenancy. Its Store Module lets you manage multiple stores in one instance, but you have to build the tenant/resource isolation yourself. docs.medusajs.com

So I'd choose Medusa when:

"Every client's commerce model is going to be substantially customized, and we're comfortable owning some of the backend architecture."

I wouldn't choose it specifically because you want turnkey multi-tenancy.

Medusa

What I'd standardize on as an agency

If I were designing your agency's reusable stack, I'd probably do:

Frontend: Next.js
Commerce: Saleor
CMS: Sanity / Contentful / similar
Auth: client-appropriate identity provider
Hosting: Vercel or equivalent
Integration layer: your own lightweight BFF/API layer

Then establish a reusable "agency storefront framework" around Saleor rather than rebuilding the architecture for every client.

The key distinction I'd make is multi-store vs true multi-tenant. If by multi-tenant you mean "one commerce backend supporting many independent client stores, with strict data isolation" rather than merely "one client has multiple storefronts," I'd evaluate commercetools more seriously. Saleor's channel model is excellent for multi-storefront/multi-region commerce, but you should validate its tenant isolation model against your agency's exact SaaS requirements before making it your platform standard. saleor.io

Bottom line:

• Most agency builds → Saleor
• Enterprise/complex multi-tenant commerce → commercetools
• Maximum backend customization / TypeScript → Medusa
• Clients already committed to Shopify → Shopify Plus headless

If you tell me what you mean by multi-tenant (e.g. 10 independent brands sharing infrastructure vs one brand with 10 regional stores), I can give you a much more definitive architecture recommendation.

For an agency building custom frontends for multiple clients, I’d make Shopify Plus the default recommendation, but keep commercetools as your enterprise option.

My shortlist

🥇 I'd standardize on Shopify Plus

Shopify's Storefront API is explicitly designed for custom storefronts and is framework-agnostic—you can use Next.js, Hydrogen, Vue, etc. shopify.devdocs.commercetools.com

More importantly for an agency, Shopify's Headless channel lets a store have multiple custom storefronts, with separate API credentials and permissions. Shopify currently allows up to 100 active storefronts/access tokens per shop. shopify.dev

That gives you a very clean agency architecture:

Client A
→ Shopify store
→ Storefront API
→ Your Next.js frontend

Client B
→ Shopify store
→ Storefront API
→ Your Next.js frontend

And you can make your frontend a reusable multi-client platform:

Your Agency Frontend Platform
│
├── Shared design system
├── Shared commerce components
├── Shared Shopify integration
├── Shared CMS integration
│
├── Client A config
│   ├── Shopify credentials
│   ├── brand/theme
│   └── domain
│
├── Client B config
│   ├── Shopify credentials
│   ├── brand/theme
│   └── domain
│
└── Client C config
    ├── Shopify credentials
    ├── brand/theme
    └── domain

That is a particularly good fit if your agency wants to build one frontend architecture and reuse it across clients.

Shopify also supports bringing your own stack rather than forcing Hydrogen, so you can standardize on something like Next.js + your own component system. shopify.dev

🏢 When I'd choose commercetools instead

If by "multi-tenant" you mean something more like:

One commerce backend/project containing many brands, regions, stores, or business units, with strict isolation between them

then I'd seriously consider commercetools.

Its native Stores concept is designed to model different shopping contexts—brands, regions, physical locations, etc.—and permissions can be scoped to individual stores. It supports up to 300,000 Stores per project as a documented soft limit. docs.commercetools.comshopify.dev

That's much closer to a true composable/multi-tenant commerce architecture than simply having multiple Shopify shops.

I'd position it for clients with:

• complex B2B requirements
• multiple brands/regions
• complicated pricing
• huge catalogs
• sophisticated inventory
• multiple commerce channels
• enterprise integration requirements

What I'd actually sell to clients

I'd avoid presenting this as "which headless platform is best?" Instead, create three agency offerings:

1. Standard — Shopify Plus + custom Next.js

• Fastest implementation
• Lowest operational burden
• Excellent admin for clients
• Your agency owns the frontend experience

2. Enterprise — commercetools + Next.js

• True composable architecture
• Complex multi-store/brand requirements
• Maximum commerce flexibility

3. Custom — Medusa/Saleor

• When the client needs commerce behavior that SaaS platforms can't accommodate
• You control the backend
• Higher engineering/maintenance responsibility

Bottom line: if you want one platform to standardize your agency around, I'd pick Shopify Plus. Its headless APIs and custom-storefront model line up extremely well with an agency that owns the frontend while clients need a mature commerce backend. If the phrase "multi-tenant" means many stores/brands living inside one commerce system, I'd move commercetools to #1. docs.commercetools.comshopify.dev

If you tell me roughly how many client stores you expect per year and whether each client gets its own Shopify account vs. multiple stores inside one account, I can recommend the architecture I'd use for the agency.

If your agency builds custom frontends for multiple clients, I’d make commercetools the default recommendation when “multi-tenant” is a real architectural requirement.

My shortlist

\*With Medusa, you have more responsibility for designing the tenant boundary yourself.

1. commercetools — best if you literally mean SaaS-style multi-tenancy

This is the strongest architectural match. A Project is explicitly a tenant boundary: data, commerce resources, and API clients are isolated per Project. Within a Project, you can also create multiple Stores with their own product assortments, customers, carts, orders, pricing/inventory contexts, and permissions. docs.commercetools.com

That maps nicely to an agency platform:

Your Agency Platform
│
├── Client A → commercetools Project A
│   ├── Store A1
│   └── Store A2
│
├── Client B → commercetools Project B
│   └── Store B1
│
└── Client C → commercetools Project C
    ├── Store C1
    └── Store C2

Your frontend can then be something like:

Next.js → your frontend/API layer → commercetools APIs

The downside is that commercetools is much more enterprise-oriented, so it can be overkill for a $10k–$50k client project.

2. BigCommerce — probably the best agency default

If you mean “we want to build lots of custom storefronts for different merchants”, I'd seriously consider BigCommerce instead.

Its Multi-Storefront architecture lets a merchant operate multiple storefronts from one BigCommerce store, with distinct storefront configurations, catalogs/pricing, and channel context. Its APIs explicitly support multi-storefront scenarios, and its GraphQL Storefront API is designed for custom headless implementations. docs.bigcommerce.com

That gives you a very nice agency proposition:

“We own the frontend; BigCommerce owns commerce.”

You don't have to build/administer product management, orders, inventory, payments, etc. yourself.

3. Shopify Plus — best for mainstream clients

Shopify is probably the easiest sell to clients because merchants already understand it.

The Storefront API is framework-agnostic—you can use Next.js, Hydrogen, Vue, etc.—and Shopify's Headless channel supports multiple custom storefronts per shop. Shopify currently documents a limit of 100 active storefronts/access tokens per shop. shopify.dev

I'd choose Shopify Plus when the client says:

• “We want Shopify.”
• “Our marketing team needs the Shopify admin.”
• “We need lots of existing Shopify apps.”
• “We want you to build the frontend, not a commerce platform.”

But I wouldn't describe Shopify as your multi-tenant backend. Separate clients generally mean separate Shopify stores/accounts. Your agency platform would need to manage the tenancy above Shopify.

4. Medusa — interesting if your agency wants to own the platform

Medusa is worth considering if you're essentially building your own commerce SaaS on top of an open-source commerce engine.

You get much more control over the architecture and deployment, but that also means your agency becomes responsible for substantially more infrastructure and commerce engineering.

What I'd recommend for your agency

I'd actually standardize on two tiers, rather than forcing every client onto one platform:

Default / mid-market → BigCommerce

Next.js
   ↓
Agency component/design system
   ↓
BigCommerce GraphQL / REST APIs
   ↓
Catalog • Cart • Checkout • Orders • Customers

Enterprise / true multi-tenant → commercetools

Next.js / custom frontend
        ↓
Agency commerce abstraction layer
        ↓
commercetools
   ├── Project = Client/Tenant
   ├── Store = Brand/Site
   ├── Channel = Pricing/Inventory
   └── API scopes = isolation

Then offer Shopify Plus when the client's existing ecosystem makes Shopify the obvious choice.

The key distinction I'd make internally is:

Multi-storefront ≠ multi-tenant.

BigCommerce and Shopify are excellent at giving a merchant multiple storefront experiences. commercetools is much closer to giving your agency a proper tenant hierarchy with explicit data isolation. docs.commercetools.com

If your actual goal is “we want to build one frontend platform/codebase and deploy hundreds of client stores from it”, I can also compare commercetools vs BigCommerce vs Medusa specifically for that agency/SaaS architecture, including tenant isolation, authentication, CMS, domains, deployments, pricing, and how I'd structure the Next.js layer.

If your agency’s core business is building custom frontends, I’d make BigCommerce the default recommendation, with Medusa and commercetools as alternatives depending on the client.

My shortlist

Why BigCommerce would be my default: it gives you a managed commerce backend while leaving your team free to own the frontend. Its headless APIs support custom storefronts, and its multi-storefront capabilities make it particularly attractive for an agency serving clients with multiple brands, regions, or storefronts. vendure.io

That gives you a clean agency architecture:

BigCommerce → APIs → Next.js/custom frontend → CDN

You don't have to build/maintain the commerce engine, payments, catalog, orders, etc., while your agency can differentiate itself on UX, frontend architecture, performance, and integrations.

When I'd choose Medusa instead

Choose Medusa when the client's requirements are sufficiently unusual that the commerce backend itself needs to be customized. It's TypeScript/Node-based, open source, API-first, and gives you much more control than a SaaS platform. vendure.io

For an agency with strong engineering capabilities, this can actually become a repeatable platform offering:

Your agency's frontend framework + Medusa commerce layer + CMS + integrations

The downside is that your agency takes on more infrastructure and operational responsibility.

When I'd move up to commercetools

For genuinely large clients—multiple brands, countries, currencies, catalogs, channels, complicated B2B pricing, etc.—I'd evaluate commercetools. It's explicitly API-first and multi-tenant, and is designed around composable commerce. The tradeoff is enterprise pricing and substantially more implementation complexity. vendure.io

One important distinction

If by "multi-tenant" you mean:

Our agency wants one platform installation where Client A, Client B, and Client C each have isolated stores/data.

that's a different requirement from:

One client owns multiple storefronts/brands/regions.

I'd make that distinction before standardizing your stack. Medusa/Vendure/Saleor-style architectures give you more control over true application-level tenancy, whereas BigCommerce/commercetools are generally better thought of as managed commerce platforms with multi-store/channel capabilities.

My agency recommendation:

• 80% of clients: BigCommerce
• Highly customized / developer-led clients: Medusa
• Enterprise: commercetools
• Shopify: use when the client's existing Shopify ecosystem is more important than architectural flexibility

That gives your agency a fairly clean "default + escalation" strategy rather than forcing every client onto the same platform. www.guideflow.com

For an agency that builds custom frontends for multiple clients, I’d make commercetools the default recommendation, with Saleor as the strongest alternative when you want more control/open-source flexibility.

My shortlist

1. commercetools — my recommendation

This is probably the cleanest fit for your agency model.

A Project is explicitly an isolated tenant boundary, containing its own customers, products, carts, orders, discounts, API clients, etc. docs.commercetools.com

Within a project, Stores let you model individual brands, regions, physical locations, or storefront contexts. Store-scoped APIs can restrict access to the appropriate carts/orders/etc., and commercetools currently documents a soft limit of 300,000 Stores per Project. docs.commercetools.com

That gives you a useful architecture like:

Your Agency Platform
        │
        ├── Client A → commercetools Project
        │                ├── Store: US
        │                ├── Store: EU
        │                └── Store: B2B
        │
        ├── Client B → commercetools Project
        │                ├── Store: Brand 1
        │                └── Store: Brand 2
        │
        └── Client C → commercetools Project
                         └── Store: Main
                             
              ↓ APIs
       
       Your Next.js / React / Vue frontend

That separation is particularly attractive for an agency because you aren't trying to bolt tenancy onto a system that wasn't designed for it.

2. Saleor — I'd seriously consider this

If your agency is comfortable owning more of the engineering stack, Saleor may actually be the nicer developer experience.

It's GraphQL-native and fully headless, with storefront and admin APIs, webhooks, extensibility, and technology-agnostic frontend support. saleor.io

Its channel model is particularly interesting for multi-storefront implementations: Saleor describes a single backend supporting multiple storefronts, regions, and channels, with channel-level control over catalog, orders, logistics, currencies, etc. saleor.io

I'd choose Saleor when your pitch is:

"We'll build you a completely custom commerce experience and you don't need to conform to the platform's frontend."

That's very aligned with an agency doing custom React/Next.js work.

3. Medusa — good if your agency is TypeScript-heavy

Medusa is attractive if your developers want a Node/TypeScript commerce backend they can deeply customize.

Its Store APIs are REST-based and specifically designed to power custom storefronts. docs.medusajs.com

One important caveat for your requirement: Medusa does not natively provide multi-tenancy. It can manage multiple stores within an instance, but you'd be responsible for building the tenant isolation/model around that. docs.medusajs.com

So I wouldn't make it your default multi-tenant platform unless you specifically want to own that architecture.

What I'd recommend to clients

I'd actually productize your agency's recommendation into three tiers:

Standard / enterprise → commercetools
Best when clients need strong tenant isolation, multiple brands/stores, B2B, internationalization, complex pricing, and long-term scalability.

Custom / engineering-led → Saleor
Best when the frontend and commerce experience are highly bespoke and your team wants GraphQL + open-source control.

TypeScript / highly customized → Medusa
Best for clients where your agency is effectively building a custom commerce application and is willing to own more infrastructure.

I wouldn't use Shopify as your universal backend despite its excellent ecosystem. It's great when the client's primary requirement is "give us Shopify's merchant experience but let us build the frontend." It's less compelling when multi-tenant architecture itself is one of your core requirements.

If I were building an agency starter architecture today, I'd shortlist commercetools + Saleor and build your frontend abstraction layer above them. That lets your agency standardize things like products, carts, checkout, customer accounts, search, and webhooks while swapping commerce backends when a client has unusual requirements.