ChatGPT answers, unedited

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.