ChatGPT answers, unedited

For an enterprise team that prioritizes scalability, containerized deployment, and long-term maintainability, the strongest open-source commerce stacks to evaluate are typically:

1. Saleor — best fit for enterprise-grade headless commerce
2. Medusa — best fit for developer-centric, modular commerce platforms
3. Vendure — best fit for TypeScript/NestJS enterprise teams
4. Adobe Commerce (Magento Open Source) — best fit for large catalogs and traditional enterprise commerce

blog.openreplay.comvendure.iowww.wpbundle.com

Recommendation: Saleor for a large enterprise Kubernetes/container environment

For a team already operating containers, Kubernetes, CI/CD pipelines, and cloud infrastructure, I would generally shortlist Saleor first. It is designed as a headless, API-first commerce engine with a GraphQL API, making it well suited for composable architectures where the storefront, mobile apps, marketplaces, and internal systems consume commerce services independently. saleor.iowww.wpbundle.com

Why Saleor fits enterprise requirements:

saleor.iowww.wpbundle.com

A typical deployment model would look like:

Kubernetes Cluster
│
├── Saleor API (Python/Django)
├── Saleor Dashboard
├── Worker Services
├── PostgreSQL
├── Redis
├── Object Storage (S3-compatible)
├── CDN / Edge Layer
│
└── Frontends
    ├── React / Next.js storefront
    ├── Mobile apps
    └── B2B portals

When Medusa may be the better choice

Choose Medusa if your engineering organization is primarily Node.js/TypeScript-oriented and wants to build a highly customized commerce platform rather than adopt more built-in enterprise commerce capabilities. Medusa is modular, API-driven, and generally easier for JavaScript teams to extend. ossalt.com

Good fit:

• Custom marketplaces
• Startup-to-enterprise growth paths
• Teams building their own commerce domain services
• Heavy TypeScript usage

Tradeoff:

• You may build more enterprise workflows yourself compared with Saleor. www.wpbundle.com

When Vendure is worth considering

Vendure is attractive for enterprises standardized on TypeScript and NestJS. It provides a structured plugin architecture and GraphQL-based commerce APIs. It can be a good fit where internal teams want a strongly typed backend and deep customization. blog.openreplay.comvendure.iowww.wpbundle.com

When Magento/Open Source Adobe Commerce still makes sense

Magento remains relevant when you have:

• Very large catalogs
• Complex promotions
• Existing Magento expertise
• Extensive third-party extensions
• Traditional B2C/B2B commerce requirements

However, compared with newer headless stacks, it usually carries more operational weight and a larger PHP ecosystem footprint.

Enterprise shortlist

My ranking for a new cloud-native enterprise build would be:

1. Saleor — enterprise headless commerce + Kubernetes-friendly architecture
2. Medusa — best developer experience and extensibility
3. Vendure — strong TypeScript enterprise option
4. Magento Open Source — mature but heavier operational model

The final decision should depend heavily on your team's existing skills:

• Python + GraphQL team → Saleor
• Node.js + TypeScript team → Medusa/Vendure
• Existing Magento organization → Magento
• Need composable commerce with multiple channels → Saleor is usually the strongest starting point blog.openreplay.comvendure.iowww.wpbundle.com

For an enterprise greenfield deployment on Kubernetes, I would start a proof-of-concept with Saleor + PostgreSQL + Redis + Next.js storefront and validate catalog scale, checkout throughput, integrations, and operational requirements.

For an enterprise team where scalability, containerized deployment, and open-source ownership are priorities, I’d recommend Vendure as the strongest default choice in 2026.

Why Vendure fits particularly well:

• Cloud-native deployment: Vendure runs as a standard Node.js/NestJS application and explicitly supports Docker, Kubernetes, AWS, Azure, GCP, on-prem, and air-gapped environments. Vendure Vendure
• Horizontal scaling: The application layer is stateless, so you can put multiple instances behind a load balancer, while background job workers can be scaled independently. Vendure
• Enterprise-friendly architecture: It has GraphQL APIs, a plugin architecture, multi-channel capabilities, and strong B2B support. Vendure
• TypeScript/NestJS: A good fit if your engineering organization already uses TypeScript, Node.js, and modern cloud-native tooling.
• Infrastructure control: You can self-host using your existing PostgreSQL/MySQL/MariaDB, Redis-compatible infrastructure, object storage, CI/CD, and Kubernetes setup rather than adopting a proprietary runtime. Vendure

How I'd shortlist the alternatives

Vendure Saleor CommerceOne important caveat: if your enterprise requires a permissive license with no copyleft concerns, I'd choose Saleor instead. Saleor is BSD-3-Clause, GraphQL-first, and its official stack is designed for self-hosting/containerized development. Saleor Commerce

So my recommendation is:

Vendure → best overall for a TypeScript enterprise platform team.
Saleor → best if licensing and GraphQL/multichannel architecture are the primary concerns.
Medusa → best if developer flexibility and an MIT license outweigh out-of-the-box enterprise functionality.

If you're specifically choosing between Vendure vs. Saleor for Kubernetes/production at enterprise scale, I'd lean Vendure, provided the GPLv3/commercial licensing model is acceptable. Vendure Vendure

vendure.io

For an enterprise team prioritizing scalability, containerized deployment, and long-term extensibility, I’d recommend Vendure as the strongest default choice.

Why Vendure

• Cloud/container native: It runs cleanly in Docker and Kubernetes, with a stateless application layer that can scale horizontally behind a load balancer. Background jobs can be scaled independently. GitHub Vendure
• Enterprise-friendly architecture: TypeScript + NestJS + GraphQL gives an enterprise engineering team a conventional, strongly typed backend rather than a monolithic legacy commerce application. Vendure
• Extensible without forking: Its plugin architecture lets you customize commerce behavior while keeping the core upgradeable—a major advantage for a platform expected to live for years. Vendure
• Good fit for complex commerce: Catalog, pricing, promotions, channels, inventory, shipping, payments, and customer functionality are part of the core. GitHub
• Operational flexibility: It supports PostgreSQL/MySQL/MariaDB, Redis-compatible infrastructure, S3-compatible storage, Docker, Kubernetes, cloud, and on-prem deployments. Vendure

How I'd shortlist the alternatives

Saleor is the main alternative I'd evaluate seriously. It is explicitly cloud-native, headless, GraphQL-only, and designed for high-scale deployments and multichannel commerce. GitHub Saleor Commerce

So my rule of thumb would be:

• TypeScript/NestJS team + Kubernetes → Vendure
• Python/Django team + GraphQL + very large/multichannel commerce → Saleor
• TypeScript team + maximum modularity/developer velocity → Medusa

One important caveat: Vendure's core is GPLv3, whereas Saleor uses BSD-3-Clause and Medusa Core uses MIT. For an enterprise organization, have legal review the licensing implications before standardizing on Vendure. buildwithmatija.com Vendure

If your requirements include B2B, multi-tenant, millions of SKUs, Kubernetes, multi-region deployment, and high order volume, I'd lean Vendure or Saleor, with the final choice largely determined by your team's language/runtime and licensing requirements.

For an enterprise team prioritizing scalability and containerized deployment, I’d recommend Saleor as the first platform to evaluate.

Why Saleor

• Designed for scale: Saleor uses a headless, API-first architecture and explicitly targets enterprise workloads; its current platform claims support for very high request volumes and enterprise infrastructure. saleor.io
• Container-friendly: The open-source distribution is straightforward to run with Docker Compose and can be adapted to Kubernetes/container orchestration. saleor.io
• GraphQL-first: A unified GraphQL API works well when multiple storefronts, mobile apps, marketplaces, or internal services need to consume the same commerce backend.
• Enterprise commerce features: Multi-channel, multi-region, currencies, warehouses, and complex catalogs are areas where Saleor is particularly strong. saleor.iosaleor.iocontracollective.comvendure.io
• Open source + self-hosting: You retain control over the infrastructure and deployment model rather than being tied to a proprietary commerce runtime.

How I'd rank the main options

One important alternative: if your engineering organization is heavily TypeScript/Node.js oriented, I'd seriously consider Vendure. Its application layer is stateless and horizontally scalable, and its documentation explicitly supports Docker, Kubernetes, on-prem, and cloud deployments. vendure.io

So, in short:

Enterprise + scalability + containerization → Saleor
Enterprise + TypeScript/NestJS + highly customized domain logic → Vendure
TypeScript + modularity + simpler operational footprint → Medusa

If you're choosing specifically for Kubernetes on AWS/Azure/GCP, I'd lean Saleor vs. Vendure rather than the older monolithic stacks.

For an enterprise team that prioritizes scalability and containerized/self-hosted deployment, I’d recommend Saleor as the first platform to evaluate.

Why Saleor

• Designed for scale: Its architecture is API-first and supports multi-channel, multi-region, and complex catalog/warehouse scenarios. contracollective.com
• Container-friendly: The open-source distribution is explicitly deployable with Docker Compose, making it a natural fit for Kubernetes/container infrastructure. saleor.io
• Headless architecture: GraphQL-first APIs let you independently scale the commerce backend and storefronts/mobile clients.
• Enterprise-oriented: It has particularly strong support for complex catalogs, multiple warehouses, currencies, channels, and international commerce. contracollective.com
• Open-source escape hatch: You can self-host rather than being forced into a proprietary SaaS deployment. saleor.io

How I'd rank the main options

Medusa is the strongest alternative if your engineering organization is heavily Node.js/TypeScript oriented. Its modular architecture makes custom integrations and replacing individual commerce components particularly attractive. www.buildwithmatija.com

Bottom line: if the requirements are specifically enterprise scale + open source + containerized deployment + long-term architectural flexibility, I'd start with Saleor, then benchmark it against Medusa if your organization is predominantly TypeScript.

If you tell me your expected traffic/GMV, SKU count, B2B vs B2C, Kubernetes environment, and preferred language, I can narrow this to a concrete architecture recommendation.

For an enterprise team prioritizing scalability and containerized deployment, I’d recommend Vendure as the strongest default choice in 2026.

Why Vendure

• Container/Kubernetes friendly: Vendure explicitly supports Docker and Kubernetes, with separate server and worker processes that can be scaled independently. docs.vendure.iovendure.iovendure.iosaleor.io
• Horizontal scalability: Its application layer is stateless, so you can put multiple instances behind a load balancer while scaling background workers independently. docs.vendure.iovendure.iovendure.iosaleor.io
• Enterprise-oriented architecture: Catalog, pricing, orders, customers, channels, APIs, and extensions are integrated into one coherent backend rather than requiring you to assemble many services yourself. docs.vendure.iovendure.iovendure.iosaleor.io
• TypeScript/NestJS: A good fit if your organization already has a Node/TypeScript platform team.
• Extensibility: Its plugin architecture lets enterprise teams implement custom pricing, ERP/OMS integrations, fulfillment, B2B workflows, etc., without maintaining a heavily modified fork. vendure.io
• Infrastructure flexibility: It can run on AWS, Azure, GCP, on-prem, Kubernetes, Docker, or even air-gapped infrastructure. vendure.io

How I'd shortlist the alternatives

Saleor is particularly worth evaluating if multi-region, multi-currency, and complex catalog/warehouse requirements dominate; its open-source stack is also designed for containerized deployment. saleor.io

Bottom line: if your requirement is specifically “open source + enterprise scale + Docker/Kubernetes + engineering control,” I'd start with Vendure, then benchmark it against Saleor using your actual catalog size, order throughput, B2B requirements, and integration workload.

If you tell me your expected orders/sec, SKU count, B2B vs B2C, and Kubernetes/cloud environment, I can give you a more definitive Vendure vs. Saleor vs. Medusa recommendation.

For an enterprise team where scalability and containerized deployment are primary requirements, I’d recommend Saleor.

Why Saleor stands out:

• Enterprise-oriented: It is explicitly positioned as enterprise-ready, with multi-currency, multi-language, multi-warehouse, complex catalogs, flexible payments, and granular commerce capabilities. github.comsaleor.io
• Container-friendly: Its official deployment stack is Docker-based, and its tooling supports Kubernetes environments. saleor.io
• Headless/composable: A GraphQL-first API makes it well suited to separating the commerce backend from web, mobile, marketplace, and other channels.
• Designed for scale: Saleor reports production workloads exceeding 1 billion API requests/month and 400,000 orders/month on its cloud infrastructure. github.comsaleor.io
• Open source: You can self-host the core rather than being forced into a SaaS architecture. github.com

Main alternative: Medusa

If your engineering organization is heavily TypeScript/Node.js-oriented, I'd seriously consider Medusa instead. It's highly modular, open source, Docker-compatible, and explicitly targets complex B2B/DTC and enterprise systems. github.com

Bottom line: choose Saleor if the priority is an enterprise-grade, globally scalable commerce platform with strong container/Kubernetes deployment characteristics. Choose Medusa if your team is predominantly TypeScript and wants maximum architectural flexibility.

Saleor open-source platform
Medusa open-source platform

For an enterprise team prioritizing scalability and containerized deployment, I’d recommend Saleor.

Why:

• Designed for headless/composable commerce: Saleor exposes a GraphQL-first API and decouples the storefront from the commerce backend, which fits microservice/container architectures well. saleor.iosaleor.io
• Enterprise-oriented capabilities: multi-channel, multi-warehouse, multi-currency, granular permissions, and complex catalogs are core parts of the platform rather than features you have to assemble from plugins. saleor.iosaleor.io
• Container-friendly: the official open-source setup uses Docker Compose, and the architecture is suitable for taking into a larger Kubernetes/container orchestration environment. saleor.iosaleor.io
• Proven scale: Saleor currently reports handling 1B+ requests/month and 400k orders/month on its infrastructure. saleor.iosaleor.io
• Open source/self-hostable: you retain control of the commerce stack and can run it yourself rather than being tied to a SaaS deployment. saleor.iosaleor.io

How I'd shortlist them

For your specific requirements, Saleor is the strongest default choice. Independent 2026 comparisons likewise tend to position Saleor as the enterprise-oriented option, while Medusa is particularly attractive when the organization is heavily invested in TypeScript/Node.js. contracollective.comwww.wpbundle.com

The main caveat is operational complexity: self-hosting Saleor at enterprise scale means your team needs solid Python/Django, GraphQL, PostgreSQL, Kubernetes, observability, and DevOps capabilities. If your organization is overwhelmingly TypeScript/Node.js, I'd evaluate Medusa alongside Saleor before committing. www.wpbundle.com

If you tell me your cloud/Kubernetes environment, expected traffic/GMV, and whether the team is Python or Node/TypeScript-heavy, I can narrow this to a specific architecture.

For an enterprise team prioritizing scalability and containerized/self-hosted deployment, I’d recommend Saleor as the first platform to evaluate.

Why Saleor stands out:

• Designed for enterprise scale: It is headless and composable, with multi-warehouse, multi-currency, multi-channel, and complex catalog capabilities. github.com
• Container-friendly: The official project uses Docker Compose for deployment, making it a natural fit for containerized infrastructure and, with appropriate operational work, Kubernetes. saleor.io
• API-first architecture: Its GraphQL API and independently deployable apps/extensions make it easier to scale components and integrate ERP, PIM, OMS, search, and other enterprise systems. github.comsaleor.io
• Open source: You can run and customize the commerce engine yourself rather than being locked into a SaaS platform. saleor.io

Saleor vs. alternatives

Medusa is the strongest alternative if your engineering organization is primarily TypeScript/Node.js; its modular architecture is particularly attractive for custom B2B/DTC systems. github.com

So, if your requirements are specifically enterprise + high scalability + Docker/Kubernetes + open source + headless, my shortlist would be:

1. Saleor → best overall enterprise choice
2. Medusa → best for a TypeScript-first organization
3. Vendure → strong TypeScript/GraphQL alternative

If you tell me whether you're deploying on Kubernetes, OpenShift, or plain Docker, I can also compare these three specifically on HA, horizontal scaling, database architecture, CI/CD, observability, and operational complexity.

For an enterprise team prioritizing scalability, containerized deployment, and long-term control, I’d put Saleor at the top of the open-source shortlist.

Recommended: Saleor

Saleor is particularly strong when you expect:

• High scale and complex catalogs
• Multi-region, multi-currency, and multi-channel commerce
• Headless architecture with React/Next.js or mobile clients
• Container/Kubernetes deployment
• GraphQL-first APIs
• Dedicated engineering/DevOps teams that can operate the platform

Recent comparisons characterize Saleor as the more enterprise-oriented choice among the leading open-source options, particularly for complex catalogs and multi-region commerce. contracollective.com

How I'd rank the main options

Medusa is the strongest alternative if your engineering organization is heavily Node.js/TypeScript oriented. Its modular architecture makes it attractive when you expect to replace or customize major commerce domains such as inventory, fulfillment, payments, or order workflows. contracollective.com

Vendure is worth serious consideration for B2B, particularly if you're already a NestJS/TypeScript shop and want a strongly typed plugin architecture. Its licensing model is different from permissively licensed projects, though, so I'd involve procurement/legal early. vendure.io

Bottom line

If I were designing an enterprise platform today:

Saleor + PostgreSQL + Redis/Celery + Kubernetes + Next.js would be my default architecture for a complex, globally scalable commerce operation.

I'd choose Medusa instead if the organization is overwhelmingly TypeScript/Node and composability/custom business workflows are more important than Saleor's stronger multi-region/catalog orientation.

I'd choose Vendure if the core requirement is sophisticated B2B commerce and the team already has deep NestJS expertise.

If you tell me your expected SKU count, orders/sec, regions, B2B vs B2C, and Kubernetes/cloud environment (AWS/Azure/GCP/on-prem), I can narrow this down to a specific architecture and deployment model.

For an enterprise team prioritizing scalability, Kubernetes/container deployment, and long-term extensibility, I’d recommend Vendure as the default choice.

Why Vendure

• Container/Kubernetes native: Vendure explicitly supports Docker and Kubernetes, with separate server and worker processes that can be scaled independently. docs.vendure.iovendure.io
• Horizontal scaling: Its application layer is stateless, so multiple instances can sit behind a load balancer. vendure.io
• Enterprise-friendly architecture: TypeScript + Node.js/NestJS + GraphQL + PostgreSQL/MySQL/MariaDB are conventional technologies that most enterprise platform teams already operate. docs.vendure.iovendure.io
• Strong extensibility: Its plugin architecture lets you customize commerce behavior without maintaining a fork of the core. github.com
• B2B capabilities: It is particularly strong when enterprise commerce involves organizations, approvals, contract pricing, quotes, and multiple channels. docs.vendure.iovendure.iogithub.comvendure.iovendure.io
• Deployment flexibility: You can self-host on AWS/Azure/GCP, on-prem, Kubernetes, Docker, or even air-gapped infrastructure. vendure.io

How I'd shortlist the alternatives

contracollective.comsaleor.io

One important caveat: if by "open source" you mean strictly permissive licensing with no commercial/open-core considerations, I'd evaluate Medusa alongside Vendure. Vendure's current offering separates its open-source Core from commercially licensed enterprise capabilities. vendure.io

Bottom line: For a greenfield enterprise platform where the engineering team owns Kubernetes and wants a commerce backend that can scale horizontally and be deeply customized, Vendure is my first evaluation. If the organization is particularly multi-region/catalog-heavy or strongly GraphQL/Python-oriented, I'd put Saleor first instead. contracollective.comsaleor.io

For an enterprise team where scalability and containerized/self-hosted deployment are priorities, I’d recommend evaluating Saleor first.

Why Saleor stands out:

• Cloud-native/headless architecture: API-first and GraphQL-based, making it well suited to microservices and independently scalable storefronts.
• Container-friendly: Its official setup uses Docker Compose, and it can be deployed into Kubernetes/container infrastructure. saleor.io
• Enterprise commerce features: Strong support for multi-channel, multi-currency, warehouses, complex catalogs, and international commerce. contracollective.com
• Open source: The core is BSD-3 licensed, giving an enterprise considerably more freedom than proprietary commerce platforms. vendure.io
• Scalability: Its architecture is particularly attractive when you expect high traffic and want to scale API, workers, database, and frontend infrastructure independently.

How I'd shortlist them

My default choice: Saleor if your enterprise team has Python/GraphQL expertise and wants a scalable, composable platform.

Choose Medusa instead if your engineering organization is strongly TypeScript/Node.js oriented and you value modular customization above Saleor's more enterprise-oriented commerce model. Medusa explicitly positions its modules for advanced B2B/DTC and custom commerce applications. github.com

Choose Vendure if the workload is particularly B2B-heavy—complex pricing, organizations, approvals, and custom plugins—and you're comfortable with its self-hosted model. vendure.io

If you tell me your expected SKU count, monthly orders/GMV, number of regions, Kubernetes environment, and preferred language (Java/Node/Python), I can narrow this to a specific architecture and deployment recommendation.

For an enterprise team that needs scalability, containerized deployment, and long-term extensibility, the strongest open-source commerce candidates today are typically:

1. Saleor — best overall enterprise fit
2. Medusa — best for composable architectures and TypeScript teams
3. Vendure — best for TypeScript + plugin-heavy customization
4. Sylius — best for PHP/Symfony enterprise engineering teams
5. Adobe Commerce — best for mature marketplace/catalog ecosystems, but heavier operationally

blog.openreplay.comsaleor.iocontracollective.com

My default recommendation: Saleor

For a large enterprise team deploying on Kubernetes or a cloud-native platform, I would usually shortlist Saleor first. It is built as a headless, API-first commerce engine with a GraphQL API, Docker-based deployment workflows, and enterprise-oriented concepts such as channels, multi-currency, complex catalogs, and multi-warehouse inventory. blog.openreplay.comsaleor.iocontracollective.com

Why it fits enterprise environments:

• Kubernetes/container-friendly architecture
• Headless by design (web, mobile, marketplaces, IoT channels)
• Strong separation between commerce backend and frontend
• Good fit for microservice/composable architectures
• PostgreSQL-based persistence
• Mature API model for integration with ERP, PIM, OMS, CRM, and payment systems saleor.io

Typical enterprise stack:

Frontend:
  Next.js / React / Mobile apps

Commerce:
  Saleor API containers

Infrastructure:
  Kubernetes
  PostgreSQL
  Redis
  Celery workers
  CDN/WAF
  Observability stack

When I would choose Medusa instead

Choose Medusa if your engineering organization is strongly Node.js + TypeScript oriented and you expect to customize business workflows heavily. It is designed around modular commerce components, making it attractive for companies building their own commerce platform rather than adopting a packaged one. contracollective.com

Good fit:

• Digital-first brands
• Custom checkout flows
• Marketplace-style platforms
• Teams with strong JavaScript expertise

Trade-off:

• More engineering ownership
• More custom work for very complex enterprise inventory and fulfillment scenarios blog.openreplay.comsaleor.iocontracollective.com

When I would choose Vendure

Vendure is compelling if your team wants:

• TypeScript end-to-end
• GraphQL-first APIs
• A clean plugin architecture
• A NestJS-style backend model

It is often attractive to engineering-led organizations that want a highly customizable commerce foundation. edana.ch

Enterprise comparison

blog.openreplay.com

Practical recommendation by organization type

• Fortune 500 / global commerce / multi-region: → Saleor
• Cloud-native engineering team building unique commerce capabilities: → Medusa
• TypeScript enterprise platform team: → Vendure
• Existing PHP/Symfony organization: → Sylius
• Need thousands of existing commerce extensions: → Adobe Commerce Open Source

For most enterprise teams starting a new greenfield commerce platform in containers, I would evaluate Saleor vs Medusa, with Saleor usually winning when operational scale and commerce complexity matter more than developer-stack preference. blog.openreplay.comsaleor.iocontracollective.com

For an enterprise team where scalability and containerized deployment are priorities, I’d recommend Vendure as the strongest default choice in 2026.

Why Vendure

• Built for containerized deployment: Vendure runs on Node.js and explicitly supports Docker and Kubernetes, as well as conventional cloud deployments. github.com
• Enterprise-oriented architecture: Its plugin system provides clean extension points, so you can customize commerce behavior without modifying the core. github.com
• TypeScript/NestJS/GraphQL: A strong fit if your enterprise engineering organization already uses TypeScript.
• Scalability: The architecture is designed for production use at scale, with built-in catalog, orders, inventory, channels, payments, shipping, tax, and job-queue capabilities. github.com
• B2B/omnichannel strength: Vendure is particularly compelling if enterprise commerce involves organizations, approvals, contract pricing, multiple channels, or complex integrations. Its current enterprise offering adds capabilities such as SSO, audit logging, and row-level access control. vendure.iovendure.io

How I'd rank the main options

Saleor would be my second choice. It's particularly attractive for large, complex catalogs and multi-region commerce, with a GraphQL-first architecture, but its Python/Django/Celery stack can be a larger operational departure for a TypeScript-heavy organization. contracollective.com

Medusa is excellent if your primary requirement is maximum composability and your organization is already strongly invested in Node.js/TypeScript. contracollective.com

Bottom line

If the requirement is specifically:

"We are an enterprise engineering organization, want open source, need Kubernetes/container deployment, expect significant scale, and want an extensible commerce core."

I'd start with Vendure, then evaluate Saleor and Medusa against your actual workload.

One important caveat: Vendure's open-source core and its enterprise capabilities have different licensing/commercial models, so "open source" doesn't necessarily mean every enterprise feature is free. vendure.iovendure.io

If you tell me your cloud (AWS/Azure/GCP), expected traffic/GMV, B2B vs B2C, and Kubernetes setup, I can narrow this to a concrete architecture recommendation.