ChatGPT answers, unedited

Yes. If your goal is “I want to own the code, database, checkout logic, and integrations, and I don't want Shopify-style platform constraints,” I'd focus on headless open-source commerce engines, rather than traditional hosted store builders.

My shortlist

1. Medusa — probably what I'd pick

Medusa official site

Medusa is particularly interesting for your use case because it's designed as a commerce framework, rather than a finished Shopify clone. Its core commerce modules are open source, and the architecture is explicitly intended for custom commerce applications. github.com

You could build something like:

                    YOUR STOREFRONT
                   Next.js / React
                         │
                         ▼
                  ┌──────────────┐
                  │    MEDUSA    │
                  │ Commerce API │
                  └──────┬───────┘
                         │
        ┌────────────────┼────────────────┐
        ▼                ▼                ▼
   Supplier API      Payments         Shipping
        │                │                │
   ┌────┴────┐       Stripe/etc.      Shippo/etc.
   │         │
AliExpress  CJ/etc.
   │
   ▼
Product sync
Inventory sync
Order submission
Tracking sync

The important part is that you can write the supplier integration yourself.

For example, you could have your own SupplierService that:

• imports products
• normalizes supplier SKUs
• updates inventory
• updates supplier prices
• submits orders automatically
• receives tracking numbers
• handles cancellations/refunds
• maps supplier variants to your internal variants

That's much closer to building your own dropshipping infrastructure than installing a dropshipping plugin.

Medusa also has a substantial developer ecosystem and its repository currently has tens of thousands of GitHub stars. github.com

2. Saleor — arguably the most powerful

Saleor

Saleor is the one I'd investigate if you're comfortable with serious backend development.

It's headless, API-only, GraphQL-native and open source, with webhooks, apps, API extensions, metadata and dashboard extensions. github.com

Its integration architecture is particularly attractive for your idea.

Saleor apps are separate applications that communicate with Saleor through GraphQL and webhooks. Their official examples include Stripe, Klaviyo, search, tax, CMS, SMTP and Segment integrations. github.com

That means you could make:

Saleor
   │
   ├── Supplier A integration
   ├── Supplier B integration
   ├── AI product enrichment
   ├── Pricing engine
   ├── Fraud system
   ├── Custom fulfillment
   ├── ERP
   └── Analytics

without stuffing everything into the core commerce application.

I'd choose Saleor over Medusa if: you want a highly composable architecture, you're comfortable with Python/GraphQL, and expect the system to become sophisticated.

3. Vendure

Vendure

Vendure is another very good choice if you want TypeScript throughout the stack.

Its architecture is plugin-oriented and headless, which is attractive for a dropshipping operation where you might eventually have custom:

• supplier plugins
• fulfillment providers
• payment providers
• pricing rules
• inventory systems
• marketplaces
• admin functionality

I'd put it roughly alongside Medusa, with the choice largely coming down to which architecture/API style you prefer.

4. WooCommerce

WooCommerce

Don't dismiss WooCommerce simply because it's older.

Its huge advantage is the ecosystem. If you need something obscure—payment gateway, tax system, shipping provider, CRM, ERP, marketplace integration, etc.—there's a much better chance somebody has already built it.

The downside is architectural: you're building on WordPress/PHP rather than starting with a clean modern commerce backend.

For “I want to build my own highly customized commerce infrastructure”, I'd personally prefer Medusa/Saleor/Vendure.

For “I want to launch quickly and leverage thousands of existing extensions”, WooCommerce becomes very attractive.

The important distinction for dropshipping

I'd actually avoid looking for an “open-source dropshipping platform.”

Instead, build:

open-source commerce engine + your own supplier abstraction layer.

That's much more powerful.

For example:

                   YOUR COMMERCE SYSTEM

                         Storefront
                            │
                            ▼
                    ┌──────────────┐
                    │   Commerce   │
                    │    Engine    │
                    └──────┬───────┘
                           │
                  Supplier Abstraction
                           │
          ┌────────────────┼─────────────────┐
          ▼                ▼                 ▼
     Supplier API      Supplier API      Supplier API
          │                │                 │
       Supplier A       Supplier B        Supplier C


                    ORDER FLOW

Customer orders
       ↓
Your database
       ↓
Payment confirmed
       ↓
Determine supplier
       ↓
Send supplier order
       ↓
Supplier confirms
       ↓
Tracking received
       ↓
Update your order
       ↓
Customer gets tracking

The supplier abstraction layer is the piece I'd consider most important.

You don't want your store's entire architecture to depend on AliExpress, CJ, Spocket, Printful, etc.

Instead, define your own interface:

Supplier
├── getProducts()
├── getProduct()
├── getInventory()
├── getPrice()
├── createOrder()
├── cancelOrder()
├── getOrderStatus()
└── getTracking()

Then every supplier implements that interface.

That gives you the ability to switch suppliers without rebuilding your store.

My ranking for your specific goal

If you're technical and want maximum control:

1. 🥇 Medusa — best balance of flexibility + developer experience
2. 🥈 Saleor — best for a sophisticated composable system
3. 🥉 Vendure — excellent TypeScript alternative
4. WooCommerce — best ecosystem, less elegant architecture
5. Sylius — excellent if you're a Symfony/PHP shop

One caveat: “open source” isn't identical across all of these projects. Medusa currently uses an open-core model, with its core under MIT while some Enterprise Edition material is commercially licensed. github.com Saleor describes its core as open source without feature fragmentation/commercial limitations. github.com

If I were starting your project today, I'd probably use Medusa + Next.js + PostgreSQL + Redis + your own supplier integration service. That gives you a very Shopify-like merchant experience while keeping the actual commerce infrastructure under your control.

If you tell me which suppliers you want to dropship from (AliExpress, CJ, Alibaba, Printful, private suppliers, etc.) and whether you're comfortable with TypeScript/Python, I can narrow this down to an actual architecture and stack.

If your goal is dropshipping with maximum control over the code, supplier integrations, order automation, and storefront, I’d strongly favor a headless open-source commerce engine over a traditional hosted platform.

My ranking

1. Medusa — my first choice for your use case

Medusa GitHub

Medusa is particularly interesting for dropshipping because it's designed as a commerce framework rather than a rigid storefront. Its core is open source under MIT, and it provides modular commerce functionality that you can build your own workflows around. github.com

You could build something like:

Customer → Next.js storefront → Medusa → your integration layer → suppliers

And have your own services handle:

• Supplier product importing
• Product normalization
• Price/margin calculation
• Inventory synchronization
• Automatic order submission
• Tracking-number synchronization
• Multiple suppliers for one product
• Supplier fallback/routing
• AI product descriptions
• Custom payment logic
• Custom shipping logic
• ERP/accounting integrations
• Automated refunds/returns

That's much closer to building your own Shopify-like system than simply installing a dropshipping plugin.

2. Saleor — excellent if you're building something ambitious

Saleor

Saleor is probably the one I'd investigate if you expect the store to become a large, sophisticated commerce system.

It's headless, GraphQL-first, open source, and has an extensive API/webhook architecture. Saleor currently advertises 160+ webhooks and extensive dashboard extensions, which is extremely useful when you're integrating external supplier/order systems. saleor.io

The tradeoff is that it's more infrastructure/engineering-oriented than WooCommerce.

I'd choose Saleor over Medusa if:

• GraphQL is important to you
• You expect multiple storefronts/channels
• You're building sophisticated catalog/marketplace functionality
• You have strong Python/GraphQL developers
• You want a very composable architecture

3. WooCommerce — best if you want to move quickly

WooCommerce developer docs

WooCommerce is open source and extremely customizable through plugins, themes and extensions. woocommerce.com

Its huge ecosystem is its biggest advantage.

For example, you could have:

WordPress + WooCommerce + custom plugin → supplier APIs

rather than building all the basic commerce functionality yourself.

The downside is that WooCommerce's architecture can become messy when you push it into a highly customized, distributed system. For a serious engineering-heavy dropshipping operation, I'd rather start with Medusa/Saleor.

4. Vendure — don't overlook this one

Vendure documentation

Vendure is particularly attractive if you're a TypeScript/Node.js developer. It's an open-source headless framework with APIs, dashboard functionality and a plugin system. docs.vendure.iosaleor.io

Its plugin architecture makes the supplier side interesting:

Vendure
   │
   ├── Supplier A plugin
   ├── Supplier B plugin
   ├── Supplier C plugin
   │
   ├── Inventory service
   ├── Pricing service
   ├── Order routing
   └── Tracking service

That's a very natural architecture for a custom dropshipping business.

What I'd actually build

If you're technical and want full ownership, I'd probably use:

Next.js
→ storefront

Medusa
→ products, customers, carts, orders, promotions

PostgreSQL
→ primary database

Redis
→ queues/cache

Your own integration service
→ supplier APIs

Webhook/event system
→ inventory + order synchronization

Stripe
→ payments

Object storage/CDN
→ product images

Scheduled workers
→ inventory/price synchronization

The important part is that I wouldn't make the supplier integration a bunch of plugins directly inside the commerce platform.

Instead:

                   ┌───────────────┐
                   │   Next.js     │
                   │   Storefront  │
                   └───────┬───────┘
                           │
                           ▼
                   ┌───────────────┐
                   │    Medusa     │
                   │ Commerce Core │
                   └───────┬───────┘
                           │
                    Events / Queue
                           │
                           ▼
                ┌─────────────────────┐
                │ Supplier Integration│
                │       Service       │
                └──────┬──────┬───────┘
                       │      │
                 ┌─────▼─┐ ┌──▼────┐
                 │Ali... │ │Supplier│
                 │       │ │   B   │
                 └───────┘ └────────┘

That gives you a supplier-agnostic architecture. If you later replace Supplier A with Supplier B, your storefront and commerce system don't need to know.

The key distinction

If you're thinking:

"I want an open-source Shopify alternative where I can install dropshipping integrations."

I'd pick WooCommerce.

If you're thinking:

"I want to build a dropshipping platform where I control every part of the integration and automation."

I'd pick Medusa.

If you're thinking:

"I'm building a serious commerce infrastructure/company and expect complicated multi-channel/catalog requirements."

I'd seriously consider Saleor.

For the specific approach you described, my shortlist would be: Medusa → Saleor → Vendure, with WooCommerce as the pragmatic alternative. saleor.io

If you tell me which suppliers you plan to use (AliExpress, CJ, Spocket, Printful, private suppliers, etc.) and whether you're comfortable with Node/TypeScript, I can narrow this down to the best architecture and explain exactly how I'd implement the supplier → inventory → order → tracking pipeline.

If your goal is a fully customizable dropshipping business—where you own the backend, can write any integration you want, and aren't locked into a SaaS platform—I'd recommend building on a headless open-source commerce engine rather than something like Shopify or Wix.

Here's how I'd rank them:

1. Medusa (my top recommendation)

This is what I'd choose if I were starting a modern dropshipping company.

Pros:

• MIT licensed
• Fully self-hosted
• TypeScript/Node backend
• Easy to create custom modules
• REST APIs and SDKs
• Supports custom payment providers
• Supports custom fulfillment providers
• Great Next.js integration
• Large plugin ecosystem

Because everything is modular, you can build integrations for:

• AliExpress
• CJ Dropshipping
• AutoDS
• Spocket
• DSers
• your own suppliers
• custom ERP
• AI pricing engines
• inventory syncing

without fighting the framework. Medusa has become one of the leading choices for developer-first headless commerce. blog.openreplay.com

2. Vendure

Vendure is fantastic if you're building something bigger.

Advantages:

• Built on NestJS
• GraphQL-first
• Extremely extensible
• Excellent plugin architecture
• Multi-vendor support
• Multi-channel support

If you eventually want:

• multiple warehouses
• multiple storefronts
• marketplace features
• advanced order routing

Vendure is arguably cleaner architecturally than Medusa.

3. Saleor

Saleor is excellent but is aimed more toward larger businesses.

Pros:

• Enterprise-grade GraphQL
• Multi-channel
• Multi-warehouse
• Strong admin UI

Cons:

• Python/Django
• More infrastructure
• Steeper learning curve

I'd pick Saleor only if your team already prefers Python or you need its advanced B2B capabilities. blog.openreplay.com

4. WooCommerce

People often recommend WooCommerce because it's popular.

I wouldn't choose it for a highly customized dropshipping platform unless you specifically want WordPress.

Problems:

• Plugin conflicts
• PHP ecosystem
• Legacy architecture
• Heavy reliance on third-party extensions

It's great for content-heavy sites but less appealing for building a highly customized commerce backend.

The architecture I'd build today

Next.js
      │
      ▼
Medusa Backend
      │
 ├── PostgreSQL
 ├── Redis
 ├── Stripe
 ├── Supplier Integrations
 ├── Shipping APIs
 ├── Inventory Sync
 └── AI Pricing Service

Then I'd add custom integrations for:

• supplier APIs
• automated inventory sync
• dynamic pricing
• automated order routing
• AI product descriptions
• email/SMS automation
• analytics dashboards

Since you own the code, you can modify every workflow.

For dropshipping specifically

Instead of relying on plugins, I'd build supplier integrations as independent services:

Supplier Connector
        │
        ├── Import products
        ├── Sync inventory
        ├── Sync prices
        ├── Push orders
        ├── Receive tracking
        └── Handle returns

This keeps your store independent of any single supplier. If you switch suppliers later, you replace only the connector rather than rewriting your storefront.

My recommendation

If you're comfortable with JavaScript/TypeScript:

• Commerce backend: Medusa
• Frontend: Next.js
• Database: PostgreSQL
• Payments: Stripe
• Authentication: Better Auth or Auth.js
• Hosting: Docker on a VPS, DigitalOcean, Hetzner, or AWS
• Supplier integrations: Your own microservices or plugins

That combination gives you complete control over the customer experience and every integration, while avoiding the lock-in and platform limits common with hosted ecommerce solutions.

If your goal is “I want to own the store, own the code, and build my own supplier/order/payment/fulfillment integrations”, I’d focus on headless open-source commerce platforms, rather than traditional dropshipping apps.

My ranking for your use case

1. Medusa — my #1 pick

For a new dropshipping operation where you expect to write a lot of your own integrations, I'd probably choose Medusa.

It's a headless, Node.js/TypeScript commerce engine designed around modularity. Its documentation explicitly supports integrating third-party services and building your own integrations, including using Medusa as a middleware layer between external systems. docs.medusajs.com

That maps extremely well to dropshipping.

You could build something like:

                  Your Store
                     │
              Next.js storefront
                     │
                     ▼
                 MEDUSA
          ┌──────────┼──────────┐
          │          │          │
       Orders     Products    Customers
          │          │
          ▼          ▼
    ┌─────────┐  ┌─────────────┐
    │ Supplier│  │ Supplier DB │
    │   API   │  │ / feeds     │
    └────┬────┘  └──────┬──────┘
         │              │
         ▼              ▼
     Inventory      Price sync
         │
         ▼
     Order routing
         │
         ▼
     Fulfillment

You could write custom modules/workflows for things like:

• supplier API synchronization
• automatic product importing
• inventory synchronization
• supplier price changes
• order routing
• automatic purchase orders
• tracking-number ingestion
• split orders across suppliers
• supplier-specific shipping rules
• product normalization
• automatic margin calculations
• returns/refunds
• fraud/risk logic
• custom payment providers
• custom ERP/WMS integrations

The big advantage: you're not trying to bend a Shopify-style application into doing something it wasn't designed for.

2. Saleor — best if you're building something substantial

Saleor is the other one I'd take very seriously.

It's open-source, headless and GraphQL-native, with an extensible dashboard, APIs and a large webhook/extension system. Saleor currently advertises 160+ webhooks and dashboard extension points, which is particularly attractive for event-driven integrations. saleor.io

Its app ecosystem already covers things such as payments, tax, CMS, search, CRM/marketing and shipping-related functionality. apps.saleor.io

I'd choose Saleor over Medusa if you're envisioning something closer to:

“I'm building an actual commerce platform/business infrastructure, not just a dropshipping website.”

For example:

              Saleor
                 │
     ┌───────────┼───────────┐
     │           │           │
 Supplier A  Supplier B  Supplier C
     │           │           │
     └───────────┼───────────┘
                 │
          Integration layer
                 │
      ┌──────────┼──────────┐
      ▼          ▼          ▼
     ERP        WMS       Analytics

Saleor's composable architecture is specifically designed around this type of setup. saleor.io

Downside: it's a more serious engineering project. If you're a solo developer trying to get a store live quickly, Medusa is probably less intimidating.

3. WooCommerce — best if you want to leverage an enormous ecosystem

Don't dismiss WooCommerce just because it's older.

It's probably the easiest platform to turn into a working business quickly because you inherit the WordPress ecosystem and a huge number of existing integrations/extensions. WooCommerce also exposes APIs suitable for headless architectures. www.wpbundle.com

For example:

Next.js
   │
   ▼
WooCommerce
   │
   ├── Custom plugin
   │      ├── Supplier API
   │      ├── Inventory API
   │      └── Fulfillment API
   │
   ├── Stripe
   ├── Tax
   └── Email

The problem is that once you start doing deep architectural customization, WooCommerce can become less elegant than something designed as an API-first commerce engine.

I'd choose WooCommerce if:

“I want to launch quickly and customize extensively.”

I'd choose Medusa if:

“I'm building the system myself and want the architecture to stay clean.”

4. Sylius — underrated option

Sylius is particularly interesting if you're a PHP/Symfony developer.

It's explicitly positioned as an open-source headless ecommerce framework for highly customized B2C/B2B applications. sylius.com

This is less:

“install a dropshipping store”

and more:

“give me a sophisticated ecommerce foundation and let me build the business logic.”

That's fantastic if your dropshipping operation has unusual requirements.

What I'd actually build

If I were starting your project today, I'd seriously consider:

Medusa + Next.js + PostgreSQL + Redis + custom supplier integration service

Something like:

                    CUSTOMER
                       │
                       ▼
                 Next.js Store
                       │
                       ▼
                    Medusa
                       │
          ┌────────────┼────────────┐
          │            │            │
       Catalog       Orders       Checkout
          │            │            │
          ▼            ▼            ▼
    Product Sync   Order Router   Payments
          │            │
          ▼            ▼
     Supplier API   Supplier API
          │            │
          ▼            ▼
      Inventory     Fulfillment
          │            │
          └──────┬─────┘
                 ▼
              Tracking
                 │
                 ▼
              Customer

Then I'd make your supplier integration layer the important part.

For example, instead of tying the store directly to one supplier:

Supplier interface

getProducts()
getProduct(id)
getInventory(id)
getPrice(id)
createOrder(order)
getOrderStatus(id)
getTracking(id)
cancelOrder(id)

Then:

AliExpressAdapter
CJAdapter
SpocketAdapter
PrintfulAdapter
PrivateSupplierAdapter

Your commerce system doesn't care who actually supplies the product.

That gives you a real dropshipping infrastructure, rather than a store that's permanently coupled to one dropshipping provider.

My recommendation

If you're technically comfortable:

🥇 Medusa — best balance of flexibility, developer experience, and custom integrations.

🥈 Saleor — choose this if you're building for serious scale/multi-channel/multi-region complexity.

🥉 WooCommerce — choose this if getting to market quickly and exploiting an existing ecosystem matters more than having the cleanest architecture.

Sylius — excellent if you're already a Symfony/PHP shop.

One important distinction: open-source commerce software doesn't automatically give you an open-source dropshipping supplier network. The store engine can be completely yours, while supplier APIs, payment processors, shipping providers, etc. remain third-party services. The architecture above is designed to keep those dependencies replaceable.

If you tell me your technical stack (JS/TS, Python, PHP, etc.) and what suppliers you want to source from, I can narrow this down to the best architecture and show you exactly how I'd structure the integrations.

Yes. If your goal is “I want to own the entire stack and write my own supplier, fulfillment, pricing, inventory, payment, and automation integrations”, I’d look at headless open-source commerce platforms, rather than a traditional Shopify alternative.

My ranking for your use case

1. 🥇 Medusa — probably what I'd choose

Medusa documentation

Medusa is particularly interesting for dropshipping because it is essentially a commerce engine/framework rather than a rigid storefront builder. Its architecture gives you modules for products, orders, inventory, fulfillment, payments, pricing, etc., while allowing you to create your own modules and workflows. docs.medusajs.com

That maps extremely well to a custom dropshipping architecture.

For example, you could build:

                    YOUR STORE
                        │
                 Next.js storefront
                        │
                        ▼
                  MEDUSA CORE
                        │
        ┌───────────────┼────────────────┐
        ▼               ▼                ▼
   Product DB       Order Engine     Customer DB
        │               │
        │               ▼
        │        DROPSHIP ORCHESTRATOR
        │               │
        │       ┌───────┼────────┐
        │       ▼       ▼        ▼
        │    Supplier A B       C
        │       │       │        │
        │       ▼       ▼        ▼
        │    Inventory / pricing / fulfillment
        │
        └──────────────► Your own business logic

Medusa explicitly supports integrating third-party systems and building workflows that span multiple systems. docs.medusajs.comdocs.medusajs.com

That means you could make your own:

• AliExpress/Alibaba supplier connector
• CJ Dropshipping connector
• Printful/Printify connector
• private supplier API connector
• supplier CSV/SFTP importer
• inventory synchronization
• automatic price synchronization
• order forwarding
• tracking-number synchronization
• supplier fallback logic
• multi-supplier routing
• automatic product importing
• margin calculation
• dynamic pricing
• fraud/order rules
• AI product enrichment

And because Medusa has a marketplace recipe, you can even model suppliers/vendors as first-class entities if that's how you want to structure your system. docs.medusajs.com

If you're comfortable with TypeScript/Node, this is my #1 choice.

2. Vendure — arguably the closest competitor

Vendure Developer Hub

Vendure is another TypeScript/Node.js headless commerce engine with a particularly powerful plugin architecture.

Its plugins can:

• add database entities
• modify GraphQL
• add new queries/mutations
• communicate with external systems
• respond to events
• run background jobs
• implement custom business logic

That's almost exactly what you want for a serious dropshipping system. docs.vendure.io

It also supports completely custom storefronts through its GraphQL API. docs.vendure.iodocs.vendure.io

Medusa vs Vendure

I'd simplify it like this:

Medusa

"Give me a commerce framework and let me build my business logic."

Vendure

"Give me a very extensible commerce server with a sophisticated plugin architecture."

Both are excellent.

For a dropshipping business, I'd probably prototype with Medusa first, then evaluate Vendure if you find yourself wanting its plugin/event architecture or GraphQL-centric approach.

3. Saleor — extremely powerful, but I'd use it for a bigger operation

Saleor Open Source

Saleor is a GraphQL-first, headless, open-source commerce platform. It is designed to be highly extensible and supports apps/extensions, webhooks and external integrations. saleor.io

It's particularly attractive if you're thinking:

"This isn't just a dropshipping store. I'm building a commerce platform."

For example, you could have:

Saleor
 │
 ├── Storefront
 ├── Supplier Service
 ├── Product Intelligence
 ├── Inventory Service
 ├── Pricing Engine
 ├── Order Router
 ├── Fulfillment Service
 ├── Analytics
 └── AI Automation

The downside is that I'd consider Saleor more infrastructure than you need for a simple first dropshipping store.

4. WooCommerce — don't underestimate it

WooCommerce

If you want to get something operational quickly, WooCommerce is still extremely compelling.

Its biggest advantage isn't necessarily the architecture.

It's the ecosystem.

There are enormous numbers of existing integrations for:

• payment processors
• shipping
• tax
• marketplaces
• email
• analytics
• suppliers
• product feeds
• fulfillment
• accounting
• CRM
• marketing

So you can choose between:

Build it yourself

or

Install an existing integration and customize it.

For a developer building a platform, I'd choose Medusa/Vendure.

For someone building a business, I'd seriously consider WooCommerce.

What I'd actually build for dropshipping

If you're serious about owning the infrastructure, I'd avoid making the ecommerce platform responsible for everything.

I'd build:

Core

Medusa

Frontend

Next.js

Database

PostgreSQL

Supplier layer

Your own service:

supplier-service/
├── suppliers/
│   ├── alibaba/
│   ├── cj/
│   ├── printful/
│   ├── supplier-x/
│   └── supplier-y/
│
├── inventory/
├── pricing/
├── products/
├── fulfillment/
└── orders/

Then create a common supplier interface:

interface Supplier {
  searchProducts(query: string): Promise<Product[]>

  getProduct(id: string): Promise<Product>

  getInventory(id: string): Promise<Inventory>

  getPrice(id: string): Promise<number>

  createOrder(order: SupplierOrder): Promise<SupplierOrderResult>

  getOrderStatus(id: string): Promise<OrderStatus>

  getTracking(id: string): Promise<TrackingInfo>
}

Now your store doesn't care whether the supplier is Alibaba, CJ, a private manufacturer, or an API you build five years from now.

That's the important architectural decision.

The architecture I'd recommend

                 ┌─────────────────┐
                 │   Next.js Store  │
                 └────────┬────────┘
                          │
                          ▼
                 ┌─────────────────┐
                 │     Medusa      │
                 │                 │
                 │ Products        │
                 │ Customers       │
                 │ Cart            │
                 │ Orders          │
                 │ Payments        │
                 │ Inventory       │
                 └────────┬────────┘
                          │
                          ▼
                 ┌─────────────────┐
                 │ Supplier Engine │
                 │                 │
                 │ Product Sync    │
                 │ Price Sync      │
                 │ Stock Sync      │
                 │ Order Routing   │
                 │ Fulfillment     │
                 └────────┬────────┘
                          │
             ┌────────────┼────────────┐
             ▼            ▼            ▼
         Supplier A   Supplier B   Supplier C

And I'd make the supplier engine independent of Medusa.

That's important because eventually you may discover that your real competitive advantage isn't the storefront—it's your supplier automation and order-routing system.

My recommendation

If you're starting from scratch today:

🥇 Medusa + Next.js + PostgreSQL
Best balance of open source, developer experience, extensibility, and custom integrations. docs.medusajs.comdocs.medusajs.com

🥈 Vendure + Next.js + PostgreSQL
I'd choose this if you particularly like TypeScript + GraphQL + a plugin/event-driven architecture. docs.vendure.iodocs.vendure.io

🥉 Saleor + custom services
I'd choose this if you're building something considerably larger than a conventional dropshipping store. saleor.io

WooCommerce
I'd choose this if speed to market and existing integrations matter more than having a clean, custom commerce architecture.

One key distinction: none of these platforms magically provides the dropshipping business layer. The open-source commerce engine gives you the foundation; the supplier/product/order synchronization layer is where you'd build your custom advantage.

If your goal is specifically "Shopify, but completely self-hosted and with my own automated supplier network/API layer", Medusa is the one I'd investigate first.

If your priority is “I own the code, can self-host it, and can build whatever integrations I want”, I’d focus on headless open-source commerce platforms, rather than traditional hosted dropshipping software.

My ranking for your use case

1. 🥇 Medusa — probably my first choice

Medusa

If you're building a custom dropshipping engine, Medusa is particularly attractive because you aren't really thinking of it as "a Shopify alternative." You're building your own commerce backend.

I'd use it if you want something like:

Supplier APIs → your integration layer → Medusa → custom storefront → payment processor → fulfillment → tracking

You can write your own supplier connectors, pricing logic, inventory synchronization, order routing, etc.

For example, you could have:

Supplier A API ─┐
Supplier B API ─┼─> Integration Service ─> Medusa
Supplier C CSV ─┘                              │
                                              ├─> Storefront
                                              ├─> Payments
                                              └─> Orders

That's a much better architecture for serious dropshipping than trying to force a generic dropshipping plugin to do everything.

2. 🥈 Vendure — excellent if you're TypeScript/NestJS oriented

Vendure

Vendure is probably the one I'd investigate alongside Medusa.

Its plugin architecture is particularly good for your use case: plugins can add database entities, extend GraphQL, interact with external systems, respond to order events, and run background jobs. docs.vendure.io

That maps extremely well to dropshipping.

You could create plugins such as:

• supplier-amazon
• supplier-aliexpress
• supplier-printful
• supplier-custom-api
• inventory-sync
• supplier-routing
• dynamic-pricing
• order-forwarding
• tracking-sync

Vendure also has a community plugin ecosystem covering things like product import/export, shipping/fulfillment, search and storage. docs.vendure.iosaleor.io

I'd choose Vendure over Medusa if your team really likes TypeScript/NestJS and you expect complicated business logic.

3. 🥉 Saleor — best if you're thinking very big

Saleor

Saleor is extremely interesting if your ultimate goal is a composable commerce platform, rather than just a dropshipping website.

It's GraphQL-first, headless, open source, and designed around external apps/services. Saleor currently advertises 160+ webhooks, dashboard extensions, dynamic models and an app ecosystem. saleor.io

That makes architectures like this very natural:

                   ┌── Supplier API #1
                   ├── Supplier API #2
Customer → Store → Saleor → Integration Layer
                   ├── ERP
                   ├── Fulfillment
                   ├── Analytics
                   └── AI/automation

The downside is that I'd consider Saleor more infrastructure than you need for a simple dropshipping business.

It's the option I'd seriously consider if you're building a platform that could eventually have:

• multiple storefronts
• multiple countries
• multiple suppliers
• multiple warehouses
• B2B + B2C
• sophisticated pricing
• custom fulfillment
• extensive automation

4. WooCommerce — the pragmatic option

WooCommerce

Don't dismiss WooCommerce just because it's less "developer cool."

For dropshipping, its enormous plugin ecosystem can save you months of development.

And you still have substantial control: WooCommerce provides APIs and webhooks, including webhooks for order/product/customer events. developer.woocommerce.com

I'd pick WooCommerce if your goal is:

"I want maximum customization, but I also want to get a functioning store online quickly."

I'd pick Medusa/Vendure instead if your goal is:

"I want to build my own commerce infrastructure and I'm comfortable writing the integrations myself."

That's an important distinction.

What I'd actually build

If you're technically capable, I'd lean toward:

Medusa or Vendure + Next.js + PostgreSQL + your own integration service

Rather than putting supplier logic directly inside the commerce platform.

For example:

                    ┌───────────────┐
                    │   Next.js     │
                    │  Storefront   │
                    └───────┬───────┘
                            │
                            ▼
                    ┌───────────────┐
                    │ Medusa/Vendure│
                    │ Commerce Core │
                    └───────┬───────┘
                            │
                     events/webhooks
                            │
                            ▼
              ┌──────────────────────────┐
              │   Integration Service    │
              │                          │
              │ Supplier adapters        │
              │ Inventory synchronization│
              │ Price synchronization    │
              │ Order forwarding         │
              │ Tracking synchronization │
              └────────────┬─────────────┘
                           │
             ┌─────────────┼──────────────┐
             ▼             ▼              ▼
        Supplier A    Supplier B     Supplier C

The integration service is the important part.

Don't make your commerce platform responsible for knowing how every supplier works. Instead, normalize suppliers behind your own interface:

interface Supplier {
  getProducts(): Promise<Product[]>
  getInventory(sku: string): Promise<Inventory>
  getPrice(sku: string): Promise<number>
  createOrder(order: Order): Promise<SupplierOrder>
  getTracking(orderId: string): Promise<Tracking>
}

Then adding another supplier becomes an adapter rather than a rewrite.

My recommendation

If you're starting from scratch today:

Medusa → best overall for a custom dropshipping business.

Vendure → best alternative if you want a very extensible TypeScript/NestJS architecture.

Saleor → best if you're deliberately building a large composable/enterprise commerce system.

WooCommerce → best if you want to leverage the existing ecosystem and get to market faster.

One other important point: don't choose based on whether the platform has a "dropshipping plugin." If your goal is full control, that's almost backwards. Choose the commerce engine with the best API, event system, extension architecture, and data model, then build your supplier layer yourself.

If you tell me what suppliers you plan to use (AliExpress, CJ, Printful, private suppliers, Amazon, wholesale APIs, etc.) and what stack you prefer (Node/Python/PHP), I can narrow this down to the best architecture and show you how I'd structure the whole system.

If your goal is “I want to own the code and build my own supplier/order/shipping/payment integrations”, I’d prioritize headless, API-first open-source commerce platforms rather than a traditional dropshipping SaaS.

My ranking for your use case

🥇 1. Medusa — probably what I'd choose

Medusa

Medusa is particularly attractive for dropshipping because it was designed as a headless, modular commerce backend rather than a website builder. Its architecture lets you customize things like payment, fulfillment, inventory, shipping and other commerce modules. www.wpbundle.com

A dropshipping setup could look like:

                YOUR STOREFRONT
                 Next.js / React
                       │
                       ▼
                  MEDUSA CORE
                       │
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
    Payments       Inventory       Orders
        │              │              │
        ▼              ▼              ▼
     Stripe       Supplier API    Supplier API
                    │ AliExpress
                    │ CJ
                    │ Printful
                    │ Private supplier
                    ▼
                 Fulfillment

The important part is that you don't have to make your store conform to the supplier's workflow.

You can build your own abstraction:

Supplier
├── getProducts()
├── getInventory()
├── getPrice()
├── createOrder()
├── getOrderStatus()
├── getTracking()
└── cancelOrder()

Then implement:

AliExpressSupplier
CJdropshippingSupplier
PrintfulSupplier
MyPrivateSupplier

Your storefront doesn't care which supplier actually fulfills the order.

That's the architecture I'd recommend if you're serious about building a dropshipping platform rather than simply operating a dropshipping store.

🥈 2. Saleor — excellent if you're building something substantial

Saleor

Saleor is even more API/composable-oriented. It's GraphQL-native and provides 160+ webhooks, customizable data models, dashboard extensions, and an app ecosystem. saleor.io

That's extremely useful for something like:

Saleor
  │
  ├── Supplier service
  │     ├── Supplier A
  │     ├── Supplier B
  │     └── Supplier C
  │
  ├── Pricing engine
  │
  ├── Inventory synchronizer
  │
  ├── Order router
  │
  ├── Shipping service
  │
  └── Analytics

Saleor also has an app system for payments, search, CMS, tax, etc., and apps can be self-hosted or modified. apps.saleor.io

I'd choose Saleor over Medusa if you're envisioning a sophisticated multi-supplier/multi-country operation, marketplace, or something that could eventually become its own commerce platform.

🥉 3. WooCommerce — best if you want to get operational quickly

WooCommerce

WooCommerce is different. It's less of a clean commerce-engine architecture and more of an enormous WordPress ecosystem.

That's actually a huge advantage for dropshipping.

There are already plugins/services for:

• supplier feeds
• product importing
• inventory synchronization
• order fulfillment
• shipping
• payment gateways
• taxes
• marketplaces
• email
• analytics

So if your goal is:

"I want a dropshipping store running next month and I'll customize it as needed."

I'd pick WooCommerce.

If your goal is:

"I'm going to build my own infrastructure and write the integrations myself."

I'd pick Medusa.

4. Sylius — extremely powerful, but more engineering-heavy

Sylius

Sylius is a Symfony/PHP-based open-source headless commerce framework designed specifically for highly customized commerce. It emphasizes replacing individual components and integrating with external PIM/CRM/marketing systems rather than locking you into one stack. sylius.com

It has a solid integration ecosystem as well. Its marketplace currently lists dozens of integration plugins. addons.sylius.com

I'd seriously consider it if your team is strong in PHP/Symfony.

The important distinction for dropshipping

I wouldn't actually look for a platform advertised as a "dropshipping platform."

I'd look for:

Open-source commerce engine + your own supplier integration layer.

For example:

                    CUSTOMER
                       │
                       ▼
                Next.js Storefront
                       │
                       ▼
                ┌─────────────┐
                │   Medusa    │
                └──────┬──────┘
                       │
                 Order Created
                       │
                       ▼
              ┌─────────────────┐
              │ Order Router    │
              └───────┬─────────┘
                      │
          ┌───────────┼───────────┐
          ▼           ▼           ▼
      Supplier A  Supplier B  Supplier C
          │           │           │
          └───────────┼───────────┘
                      ▼
                  Fulfillment
                      │
                      ▼
                 Tracking API
                      │
                      ▼
                   Customer

That gives you supplier independence.

If Supplier A changes its API, you modify one adapter instead of rebuilding your store.

My recommendation

If you're technically capable:

Medusa + Next.js + PostgreSQL + Redis + your own supplier adapter service

would be my first choice.

If you're building something more enterprise/composable:

Saleor + Next.js + custom supplier/order services

would be my second.

If you want maximum existing ecosystem and minimum initial development:

WooCommerce + custom plugins/services

would be the pragmatic choice.

And if you're already a Symfony/PHP shop:

Sylius is absolutely worth considering.

The biggest mistake I'd avoid is choosing a platform because it has a "dropshipping integration." Build the supplier layer yourself and make the commerce platform supplier-agnostic. That gives you substantially more control over margins, routing, inventory, pricing, fulfillment and eventually switching suppliers.

Yes. If your goal is dropshipping + maximum control over integrations, I’d favor a headless/open-source commerce backend over something like Shopify. That lets you own the code, database, APIs, supplier logic, order routing, pricing rules, and storefront.

My shortlist

1. Medusa — my first choice

Medusa is particularly interesting for what you're describing. It's MIT-licensed, TypeScript/Node-based, and designed as a customizable commerce framework rather than a traditional hosted store. Its modules are open source and it explicitly supports building custom commerce applications. github.com

Medusa GitHub

For dropshipping, you could build something like:

                 YOUR STOREFRONT
                Next.js / React
                       │
                       ▼
                ┌─────────────┐
                │    MEDUSA   │
                │   Commerce  │
                └──────┬──────┘
                       │
       ┌───────────────┼────────────────┐
       ▼               ▼                ▼
   Supplier A      Supplier B       Supplier C
   API            API / CSV         API / EDI
       │               │                │
       └───────────────┼────────────────┘
                       ▼
                 Order Router
                       │
              ┌────────┴────────┐
              ▼                 ▼
          Fulfillment       Tracking

You could write your own supplier adapter layer, for example:

SupplierAdapter
├── getProducts()
├── getInventory()
├── getPrice()
├── createOrder()
├── cancelOrder()
└── getTracking()

That is much more interesting for a serious dropshipping operation than relying on a marketplace plugin.

2. Vendure

I'd look very closely at Vendure if your business logic is going to get complicated.

Vendure is TypeScript/Node/NestJS with GraphQL and a plugin-first architecture, so you can extend or override functionality without modifying the core. github.com

Vendure GitHub

This is particularly attractive if you eventually want:

• multiple suppliers per product
• supplier-specific inventory
• automated supplier selection
• complex pricing
• B2B
• multiple warehouses
• marketplace functionality
• custom fulfillment workflows
• sophisticated order splitting

One caveat: Vendure Core is GPLv3, so its licensing deserves careful consideration if you're building proprietary software around it. github.com

3. Saleor

Saleor is another serious option, particularly if you're comfortable with Python and GraphQL.

It is built around a GraphQL API and a composable architecture, and its official project explicitly emphasizes integrations, extensions, webhooks, and self-hosting. saleor.io

Saleor Open Source

I'd pick Saleor over Medusa if you anticipate a larger, more sophisticated commerce operation and your team is comfortable with Python/Django/GraphQL.

4. WooCommerce

Don't dismiss WooCommerce just because it's older.

Its biggest advantage is the enormous ecosystem. If you want to get a dropshipping store operational quickly while retaining the ability to write custom PHP/plugins, WooCommerce is hard to beat.

But there's an architectural distinction:

WooCommerce

WordPress → WooCommerce → plugins → custom code

Medusa/Vendure/Saleor

Your frontend → API → commerce engine → your integrations

If you're specifically saying "I want to build my own integrations and own the architecture", I'd lean toward the second model.

What I'd actually build for your use case

If I were designing a new dropshipping operation today, I'd probably go:

Next.js + Medusa + PostgreSQL + custom integration service

with something like:

                    ┌──────────────┐
                    │   Next.js    │
                    │  Storefront  │
                    └──────┬───────┘
                           │
                           ▼
                    ┌──────────────┐
                    │    Medusa    │
                    │   Commerce   │
                    └──────┬───────┘
                           │
                ┌──────────┴──────────┐
                │                     │
                ▼                     ▼
        ┌──────────────┐      ┌──────────────┐
        │ Integration  │      │   Payment    │
        │    Service   │      │   Provider   │
        └──────┬───────┘      └──────────────┘
               │
      ┌────────┼─────────┐
      ▼        ▼         ▼
   Supplier  Supplier  Supplier
      A        B          C
      │        │          │
      └────────┼──────────┘
               ▼
       Inventory / Pricing
          Normalization
               │
               ▼
          Order Routing
               │
               ▼
          Fulfillment

The integration service is the important part.

Don't make your commerce platform directly understand every supplier's API. Instead, normalize suppliers into your own internal interface.

For example:

interface Supplier {
  products(): Promise<Product[]>
  inventory(sku: string): Promise<number>
  price(sku: string): Promise<number>
  placeOrder(order: Order): Promise<SupplierOrder>
  cancelOrder(id: string): Promise<void>
  tracking(id: string): Promise<Tracking>
}

Then adding a new supplier becomes:

supplier-amazon.ts
supplier-alibaba.ts
supplier-printful.ts
supplier-wholesaler-x.ts

rather than rewriting your entire store.

The important distinction

If you're just trying to start selling products, I'd choose WooCommerce.

If you're trying to build a custom dropshipping system that happens to have a storefront, I'd choose Medusa.

If you're building something that could eventually become a complex multi-supplier/multi-channel commerce platform, I'd seriously compare Medusa vs Vendure vs Saleor before committing. Current 2026 comparisons similarly put those three at the top of the modern open-source headless category. blog.openreplay.com

My ranking for your stated goal:

1. 🥇 Medusa — best balance of openness, TypeScript, flexibility and developer experience
2. 🥈 Vendure — fantastic if your business logic/workflows will become complex
3. 🥉 Saleor — excellent if you prefer Python/GraphQL and want a more enterprise-oriented architecture
4. WooCommerce — best ecosystem/fastest route to a conventional store
5. Sylius — excellent if your team is strongly invested in Symfony/PHP

If you tell me where you plan to source products (AliExpress, Alibaba, CJ, private wholesalers, Printful, etc.) and whether you want to use Next.js/React, I can narrow this down to an actual architecture and explain how I'd handle product importing, inventory sync, dynamic pricing, order routing, fulfillment, tracking, and supplier failover.

Yes. If your goal is “I own the code, can self-host it, and can build custom supplier/order/inventory integrations without fighting the platform”, I’d look at headless open-source commerce, rather than a traditional dropshipping SaaS.

My ranking for your use case

1. Medusa — my first choice

Medusa is particularly interesting for what you're describing because it's TypeScript/Node.js and designed around modular commerce. Its open-source modules cover things like products, orders, payments and fulfillment, while you can build your own modules around them. github.comwww.wpbundle.com

For dropshipping, I'd architect it something like:

                    ┌── Supplier API #1
                    ├── Supplier API #2
                    ├── AliExpress / CJ / other supplier
                    ├── Custom supplier CSV/SFTP
                    └── Your own supplier database
                              │
                              ▼
Customer → Next.js → Medusa → Order Orchestrator
                         │          │
                         │          ├── supplier selection
                         │          ├── inventory sync
                         │          ├── order submission
                         │          ├── tracking updates
                         │          └── returns/refunds
                         │
                         ├── Stripe
                         ├── Email/SMS
                         └── Analytics

That architecture gives you substantially more control than building around Shopify apps.

The big advantage: you can make the supplier integration itself part of your application, rather than hoping an app exists that does exactly what you want.

2. Vendure

I'd seriously consider Vendure if your business logic is going to get complicated.

It's TypeScript/Node.js, GraphQL-based, and has a plugin architecture specifically intended for extending the commerce engine. Its open-source Core provides the commerce engine, APIs, dashboard and plugin system. docs.vendure.io

It's particularly attractive if you eventually want things like:

• multiple suppliers for the same SKU
• automatic supplier selection
• supplier-specific pricing
• multiple warehouses
• B2B pricing
• marketplaces
• complicated fulfillment rules
• custom order workflows

Vendure's own positioning emphasizes complex B2B, D2C and marketplace models and deep integrations with ERP/PIM/OMS/WMS/fulfillment systems. vendure.io

I'd choose Vendure over Medusa if your dropshipping engine is going to become a fairly sophisticated supply-chain system.

3. Saleor

Saleor is another excellent option, especially if you're comfortable with Python + GraphQL.

It's explicitly designed as a composable, headless platform with a GraphQL API and extensible apps. You can self-host the entire stack and customize the API/dashboard rather than being confined to a hosted SaaS model. saleor.io

I'd put it ahead of Medusa if you're building something more like:

"A serious commerce infrastructure platform that happens to power my dropshipping business."

rather than:

"I want to build a highly customized dropshipping store."

4. WooCommerce

Don't overlook WooCommerce.

It's less elegant architecturally, but its enormous plugin ecosystem can save you months of development. You can also run it headless and put a custom React/Next.js frontend on top.

The tradeoff is that WooCommerce's enormous ecosystem comes with a lot of WordPress/PHP/plugin complexity. Medusa, Vendure and Saleor are much more attractive if you're intentionally building a software-heavy system. www.wpbundle.com

What I'd actually build

If I were building your system from scratch today, I'd probably use:

Frontend

• Next.js
• TypeScript
• Tailwind

Commerce

• Medusa

Database

• PostgreSQL

Payments

• Stripe

Infrastructure

• Docker
• AWS / Hetzner / DigitalOcean
• Cloudflare

Integrations

• Custom TypeScript supplier adapters
• Webhooks
• Queues/workers for supplier synchronization

Search

• Meilisearch or OpenSearch

Automation

• Redis + BullMQ, or a similar job system

And I'd deliberately create a supplier abstraction layer:

interface Supplier {
  getProduct(sku: string): Promise<Product>;
  getInventory(sku: string): Promise<number>;
  getPrice(sku: string): Promise<number>;

  createOrder(order: Order): Promise<SupplierOrder>;
  cancelOrder(orderId: string): Promise<void>;

  getTracking(orderId: string): Promise<TrackingInfo>;
}

Then:

Supplier
   │
   ├── CJAdapter
   ├── AliExpressAdapter
   ├── PrintfulAdapter
   ├── SupplierXYZAdapter
   └── CustomSupplierAdapter

Your store doesn't care who the supplier is.

That becomes extremely valuable once you have multiple suppliers. You can implement logic such as:

Customer orders SKU-123
        ↓
Find suppliers carrying SKU-123
        ↓
Check inventory
        ↓
Compare landed cost
        ↓
Check shipping destination
        ↓
Choose supplier
        ↓
Submit purchase order
        ↓
Receive tracking
        ↓
Update customer order

That's where I think open source becomes much more interesting than simply using an open-source storefront.

My recommendation

If you're comfortable developing software:

🥇 Medusa → best starting point
🥈 Vendure → best if you anticipate sophisticated commerce/supplier workflows
🥉 Saleor → best if you prefer Python/GraphQL and want a very composable architecture
WooCommerce → best if minimizing development time matters more than architectural cleanliness

One important distinction: none of these is inherently a “dropshipping platform.” They're commerce engines. That's actually a benefit for your stated goal—you build the dropshipping/supplier layer yourself instead of having the business model dictated by a dropshipping SaaS.

If you tell me what suppliers you plan to use (e.g. AliExpress, CJ, Amazon, Printful, private suppliers, wholesale distributors) and whether you're comfortable with Node/TypeScript, I can narrow this down to a specific architecture and explain exactly how I'd implement the supplier/order-sync layer.

Yes. If your goal is “I own the store, database, checkout logic, supplier integrations, and can modify essentially everything”, I’d favor a headless open-source commerce backend over a traditional dropshipping platform.

My shortlist

1. Medusa — my first choice

For what you're describing, Medusa is probably the one I'd start with.

It's built as a customizable commerce framework rather than a locked-down storefront. You can create custom API routes, data models, workflows, modules, scheduled jobs, and integrations. Medusa specifically documents using it as a middleware layer between your store and external systems. docs.medusajs.com

That maps extremely well to dropshipping.

For example, you could build:

Customer
   ↓
Your Next.js storefront
   ↓
Medusa
   ├── Products
   ├── Pricing
   ├── Cart
   ├── Checkout
   ├── Orders
   └── Customers
        ↓
     Your Order Workflow
        ├── Supplier A API
        ├── Supplier B API
        ├── Supplier C API
        └── Custom supplier
               ↓
        Tracking number
               ↓
          Customer

You could also build your own supplier abstraction:

SupplierInterface
├── getProducts()
├── getInventory()
├── createOrder()
├── cancelOrder()
├── getOrderStatus()
└── getTracking()

Then every supplier becomes a module/adapter rather than your business logic being tied to AliExpress, CJ, a particular wholesaler, etc.

That's much closer to building your own dropshipping infrastructure than using something like Shopify + a dropshipping app.

2. Vendure — excellent alternative

Vendure would be my #2, and arguably #1 if you're particularly comfortable with TypeScript.

Its plugin architecture is extremely suitable for what you're describing. Plugins can modify the data model, extend GraphQL, interact with external systems, respond to order events, and run background jobs. docs.medusajs.comdocs.vendure.iodocs.vendure.iodocs.vendure.iodocs.saleor.iodocs.medusajs.com

That's useful for things like:

Order placed → reserve supplier inventory → submit supplier order → receive supplier confirmation → update customer order → process tracking webhook.

Vendure also has an explicit example of building multi-vendor marketplace functionality, which demonstrates how deeply its commerce model can be customized. docs.vendure.io

Its current ecosystem includes community plugins for things such as product import/export, search, shipping extensions, fulfillment, and Sendcloud. docs.vendure.io

One important distinction: Vendure Core is open source, while Vendure also sells a commercial Platform containing additional enterprise functionality. docs.vendure.io

3. Saleor — powerful, but I'd choose it for a different reason

Saleor is particularly attractive if you want a GraphQL-first, highly composable architecture.

It has APIs, extensions, apps, webhooks, multi-region capabilities, channels, and a substantial integration model. Its app ecosystem includes payment, CMS, tax, search and other integrations. docs.saleor.io

I'd consider Saleor if you're thinking:

"I'm eventually building a serious commerce platform with multiple markets, currencies, catalogs, warehouses, etc."

For a relatively straightforward dropshipping operation, though, I think Medusa gives you a more natural starting point.

4. WooCommerce — underrated choice

Don't dismiss WooCommerce.

It's considerably less elegant architecturally than Medusa/Vendure if you're building a sophisticated custom system, but its enormous ecosystem can save you months of development.

If you want:

• WordPress
• lots of existing plugins
• supplier integrations
• payment integrations
• SEO tooling
• merchant/admin tooling
• relatively easy deployment

then WooCommerce is still compelling.

The tradeoff is that you're customizing WordPress/WooCommerce, rather than starting with a clean commerce backend designed around APIs and modular services.

What I'd build for your use case

If you're technical and genuinely want full control, I'd probably use:

Medusa + Next.js + PostgreSQL

with something like:

                    ┌──────────────────┐
                    │    Next.js       │
                    │   Storefront     │
                    └────────┬─────────┘
                             │
                        REST/API
                             │
                    ┌────────▼─────────┐
                    │     Medusa       │
                    │ Commerce Engine   │
                    └────────┬─────────┘
                             │
             ┌───────────────┼────────────────┐
             │               │                │
        ┌────▼────┐    ┌────▼────┐     ┌────▼────┐
        │Supplier │    │Supplier │     │Supplier │
        │ Adapter │    │ Adapter │     │ Adapter │
        │    A    │    │    B    │     │    C    │
        └─────────┘    └─────────┘     └─────────┘
             │               │                │
             └───────────────┼────────────────┘
                             │
                    ┌────────▼────────┐
                    │ Order/Inventory │
                    │   Orchestrator  │
                    └─────────────────┘

Then I'd keep supplier logic completely separate from the commerce engine.

That gives you the ability to switch suppliers without rebuilding your store.

The really important part

Don't think of the project as:

"I need a dropshipping store."

Think of it as:

"I need a commerce engine + supplier orchestration system."

The storefront is actually the easy part.

The interesting/customizable pieces are:

• supplier product ingestion
• SKU normalization
• supplier inventory synchronization
• price calculation
• automatic markup
• product deduplication
• supplier selection
• order routing
• split orders
• supplier API failures/retries
• tracking synchronization
• refunds/cancellations
• inventory discrepancies
• shipping-rate calculation
• webhook processing
• customer notifications

That's where an open-source, code-first platform becomes much more valuable than Shopify/Wix/etc.

My ranking for your specific goal:

🥇 Medusa — best balance of freedom + modern architecture
🥈 Vendure — arguably best if you want everything expressed as TypeScript plugins
🥉 Saleor — excellent for a more sophisticated GraphQL/multi-region operation
4. WooCommerce — best if ecosystem and speed matter more than architectural purity
5. Shopware — worth considering for larger traditional commerce operations

If you're starting from scratch, I'd lean Medusa + Next.js + PostgreSQL and build your own supplier adapter layer. Medusa's current framework explicitly supports custom modules, workflows, API routes and third-party integrations, which is almost exactly the architecture I'd want for this. docs.medusajs.comdocs.medusajs.com

Medusa documentation
Vendure documentation
Saleor documentation

If your goal is a dropshipping store where you own the code, data, integrations, and infrastructure, I’d focus on headless open-source commerce platforms rather than traditional hosted storefronts.

My ranking

1. Medusa — my first choice

Medusa is probably the closest match to what you're describing. It's a headless, Node.js/TypeScript commerce engine with its commerce modules open source and designed specifically to be customized rather than forcing you into a particular SaaS workflow. github.com

For dropshipping, you could build your own integration layer:

Storefront → Medusa → your orchestration layer → suppliers

For example:

• Customer places order
• Medusa creates the order
• Your integration service determines the supplier
• Supplier API receives the order
• Supplier confirms fulfillment
• Tracking number comes back
• Your service updates Medusa
• Customer gets tracking information

You could also implement custom supplier-selection logic such as:

lowest landed cost → available inventory → fastest shipping → supplier reliability

That's much easier to own with a headless platform than trying to bend Shopify/Wix/etc. around your workflow.

2. Vendure — excellent alternative

Vendure is particularly interesting if you expect your dropshipping operation to become integration-heavy.

Its plugin architecture lets you add business logic, new database entities, GraphQL APIs, external-system integrations, event handlers, and background jobs without modifying the core. docs.vendure.io

That maps extremely well to things like:

• Supplier APIs
• Inventory synchronization
• Automated purchasing
• Order routing
• Supplier-specific pricing
• Multi-supplier products
• Shipping-rate aggregation
• Returns automation
• Marketplace integrations

Vendure also has an existing plugin ecosystem covering areas such as shipping/fulfillment, import/export, search, payments and infrastructure. github.comdocs.vendure.iosaleor.io

If you're primarily a TypeScript/NestJS developer, I'd seriously consider Vendure over Medusa.

3. Saleor — best if you're building something ambitious

Saleor is very API-centric: GraphQL, webhooks, apps, metadata, dashboard extensions and a composable architecture. Its current platform advertises 140+ webhook events and lets you host integrations yourself. saleor.io

That's powerful for a custom dropshipping infrastructure.

For example, you could have:

                   ┌── Supplier A
                   ├── Supplier B
Storefront
     │             ├── Supplier C
     ▼             └── Supplier D
  Saleor
     │
     ├── Pricing service
     ├── Inventory service
     ├── Supplier router
     ├── Fulfillment service
     └── Analytics

I'd choose Saleor if you're thinking "I'm essentially building my own commerce platform/business infrastructure", rather than simply launching a dropshipping store.

4. WooCommerce — boring, but extremely practical

Don't overlook WooCommerce.

If your primary objective is getting a store operational quickly while retaining enormous customization potential, WooCommerce has a huge advantage: the WordPress ecosystem.

The tradeoff is architectural. You're extending WordPress/WooCommerce rather than starting with a clean headless commerce engine. That's great for conventional stores, but less attractive if you're planning a sophisticated supplier-orchestration system.

What I'd actually choose

For your particular requirement:

If you're a JS/TS developer:
→ Medusa or Vendure

If you want maximum API/composable architecture:
→ Saleor

If you want to launch quickly and leverage thousands of existing extensions:
→ WooCommerce

If you anticipate enterprise-scale catalog/order complexity:
→ Saleor or Vendure

I would not start with Magento unless you already have a strong reason to use it. It's extraordinarily customizable, but you're taking on substantially more platform complexity than you need for most dropshipping businesses.

One important distinction

I'd separate the commerce platform from the dropshipping integration system.

Don't try to make Medusa/Vendure/Saleor itself responsible for every supplier-specific quirk.

Instead:

                    YOUR SYSTEM
                         │
              ┌──────────┴──────────┐
              │                     │
        Commerce Engine       Integration Layer
              │                     │
         Medusa/Vendure       Supplier adapters
              │               ┌─────┼─────┐
              │               │     │     │
              │              API   API   CSV
              │               │     │     │
              └───────────────┴─────┴─────┘

Then create a normalized internal supplier interface, e.g.:

getProducts()
getInventory()
getPrice()
createOrder()
cancelOrder()
getShipment()
getTracking()

Each supplier gets its own adapter.

That way, if you replace Supplier A with Supplier B, your store doesn't care. You just replace the adapter.

For a highly customizable dropshipping business, that's the architecture I'd favor over installing a generic "dropshipping plugin."

If you tell me your preferred stack (Node/TS, Python, PHP, etc.) and whether you're planning AliExpress/Alibaba, US wholesalers, Printful/Printify, or your own supplier APIs, I can narrow this down to a specific stack and architecture.

If your goal is a dropshipping store where you own the code, can build custom supplier integrations, automate workflows, and avoid Shopify-style constraints, you should lean toward headless/open-source commerce platforms rather than traditional hosted carts. The best choice depends heavily on your tech stack and how much you want to build yourself. blog.openreplay.comwww.wpbundle.comwww.wpbundle.com

My shortlist:

blog.openreplay.comwww.wpbundle.com

My recommendation by scenario

1. You want a serious custom dropshipping engine → Medusa

This is probably the strongest fit if you are building something like:

• supplier API connectors
• automatic product importing
• price synchronization
• inventory syncing
• AI product enrichment
• custom fulfillment rules
• marketplace integrations
• custom customer experiences

Medusa is built around modular commerce services, so you can replace or extend pieces like payments, fulfillment, shipping, and workflows without fighting a monolithic system. It is especially attractive if you use Node.js + TypeScript + React/Next.js. blog.openreplay.comwww.wpbundle.comwww.wpbundle.com

Typical stack:

Next.js storefront
        |
Medusa commerce backend
        |
PostgreSQL
        |
Custom supplier connectors
        |
ERP / warehouses / marketplaces

2. You want to get selling quickly but still customize → WooCommerce

WooCommerce is still hard to beat if you need:

• hundreds of existing integrations
• SEO/content marketing
• easy admin experience
• payment/shipping plugins
• lower development effort

For dropshipping specifically, there are many existing integrations because of the WordPress ecosystem. The downside is that deep custom automation can become plugin-heavy and messy compared with a purpose-built headless backend. blog.openreplay.comwww.wpbundle.comwww.wpbundle.com

A powerful architecture is:

WordPress + WooCommerce backend
              |
        Custom API services
              |
       Supplier integrations
              |
     Next.js custom storefront

3. You are building a large operation → Saleor

Saleor makes sense if you are thinking:

• multiple suppliers
• multiple warehouses
• international markets
• multiple currencies
• complex permissions
• enterprise workflows

It is more of a "build a commerce platform" choice than a "launch a dropshipping store" choice. blog.openreplay.comwww.wpbundle.com

Platforms I would avoid for your goal

Shopify

Great for validation, but if your long-term goal is:

• custom supplier networks
• unusual automation
• owning the infrastructure

you will eventually fight the platform.

Magento / Adobe Commerce Open Source

Very powerful, but often too heavy unless you already have enterprise-level requirements and developers.

PrestaShop/OpenCart

Good traditional stores, but I would not choose them for a modern API-driven dropshipping architecture.

The architecture I would build today for a highly customizable dropshipping business

Frontend

• Next.js
• Tailwind
• React components

Commerce engine

• Medusa

Database

• PostgreSQL

Automation layer

• Node.js workers
• Redis queues

Supplier integrations

• Custom connectors:
  • AliExpress API
  • CJdropshipping
  • Printful
  • private suppliers
  • wholesalers
  • custom CSV/XML feeds

Operations

• Webhooks for:
  • inventory changes
  • order creation
  • fulfillment updates
  • tracking numbers

AI layer

• Product title rewriting
• SEO generation
• Image enrichment
• Demand analysis

If I were choosing for a developer who wants maximum control, my ranking would be:

1. Medusa — best balance of flexibility + modern architecture
2. WooCommerce headless — best ecosystem and fastest path to revenue
3. Saleor — best for a large-scale commerce platform
4. Vendure — great TypeScript alternative
5. Sylius — excellent but more specialized

blog.openreplay.comwww.wpbundle.comwww.wpbundle.com

The biggest decision is whether you want to build a store or a dropshipping platform. For a store, WooCommerce may be enough. For a platform that connects suppliers, automates sourcing, and has proprietary workflows, I would start with Medusa.

If your priority is “I want to own the stack and be able to build arbitrary dropshipping integrations”, I’d focus on headless, self-hostable commerce engines, rather than traditional hosted platforms.

My ranking for your use case

Modern headless comparisons put Medusa, Saleor, and Vendure at the top of the open-source category, with Medusa particularly aimed at modular, developer-driven commerce. vendure.io

1. 🥇 Medusa — probably what I'd choose

Medusa GitHub

Medusa is particularly interesting for dropshipping because you can treat the store as a commerce engine rather than the entire business.

Its modules cover things like:

• products/catalog
• carts
• orders
• payments
• inventory
• fulfillment
• shipping
• promotions

And those pieces are designed to be customized or replaced. Medusa describes itself as a commerce platform with a built-in framework for customization, with its commerce modules available as open source. github.com

That maps extremely well to a dropshipping architecture.

For example:

                    YOUR STOREFRONT
                 Next.js / React / etc.
                           │
                           ▼
                    ┌─────────────┐
                    │   MEDUSA    │
                    │   COMMERCE  │
                    └──────┬──────┘
                           │
          ┌────────────────┼────────────────┐
          ▼                ▼                ▼
     Supplier API     Supplier API     Supplier API
       AliExpress       CJdropship       Custom ERP
          │                │                │
          ▼                ▼                ▼
       Products         Products         Products
       Inventory        Inventory        Inventory
       Orders           Orders           Orders
       Tracking         Tracking         Tracking

The important part is that you control the integration layer.

You could build something like:

Supplier A
    ↓
Product normalization
    ↓
Your supplier database
    ↓
Medusa catalog
    ↓
Your storefront

Then separately:

Customer order
      ↓
Medusa
      ↓
Supplier routing engine
      ↓
Supplier API
      ↓
Purchase order
      ↓
Tracking number
      ↓
Medusa order
      ↓
Customer

That gives you substantially more freedom than trying to force a dropshipping workflow through Shopify's prescribed architecture.

License is also attractive: Medusa is MIT-licensed according to current comparisons. vendure.io

2. 🥈 Saleor — excellent if you're building something sophisticated

Saleor

Saleor is another very strong choice. It's open source, headless, GraphQL-first, and designed around extensibility. Its official site specifically emphasizes integrating with anything and self-hosting the platform. saleor.io

I'd consider Saleor over Medusa if you're planning something like:

• multiple storefronts
• multiple countries
• multiple warehouses
• sophisticated catalog structures
• multiple currencies
• complex tax rules
• B2B + B2C
• very GraphQL-heavy architecture

Saleor also has an app/extension model for things like payments, CMS, search and taxes. saleor.io

The downside for a typical JavaScript-heavy startup is that Saleor's backend is Python/Django, whereas Medusa is much more natural if you're building everything in TypeScript.

3. 🥉 Vendure — extremely compelling for a TypeScript shop

Vendure

Vendure is built with TypeScript, NestJS, React and GraphQL, and its core is open source. github.com

Its big advantage is its plugin architecture.

If your business logic eventually becomes:

"When an order contains these products, from this country, going to this region, use Supplier X unless their inventory is below Y, otherwise use Supplier Z."

Vendure is a very good kind of architecture for that.

Its documentation specifically highlights advanced pricing, workflow automation, search, audit logging and B2B capabilities. docs.vendure.io

One thing to investigate carefully is licensing: Vendure Core is currently GPLv3, while additional platform functionality has its own commercial licensing. github.com

What I'd actually build for dropshipping

If you're serious about owning the integration layer, I wouldn't make the commerce platform responsible for everything.

I'd use something closer to:

                    ┌───────────────────┐
                    │     Next.js       │
                    │    Storefront     │
                    └─────────┬─────────┘
                              │
                              ▼
                    ┌───────────────────┐
                    │      Medusa       │
                    │ Commerce Engine   │
                    └─────────┬─────────┘
                              │
                    ┌─────────▼─────────┐
                    │ Integration Layer │
                    │                   │
                    │ Supplier adapters │
                    │ Product sync      │
                    │ Inventory sync    │
                    │ Order routing     │
                    │ Tracking          │
                    │ Pricing           │
                    └────┬────┬────┬────┘
                         │    │    │
                         ▼    ▼    ▼
                       API  API  API
                       S1   S2   S3

The integration layer is the important part.

I'd give every supplier a common interface:

interface Supplier {
  getProducts(): Promise<Product[]>
  getInventory(sku: string): Promise<number>
  getPrice(sku: string): Promise<number>
  createOrder(order: Order): Promise<SupplierOrder>
  getOrderStatus(orderId: string): Promise<OrderStatus>
  getTracking(orderId: string): Promise<Tracking>
}

Then:

AliExpressSupplier
CJdropshippingSupplier
PrintfulSupplier
WholesaleSupplier
YourCustomSupplier

all implement the same interface.

That means you aren't architecturally tied to any particular dropshipping company.

Where WooCommerce fits

WooCommerce

Don't dismiss WooCommerce.

It has a gigantic ecosystem, and if your goal is:

"I want to launch quickly and there are probably already plugins for 80% of what I need."

then WooCommerce can actually be the better business decision. Its enormous plugin ecosystem is one of its biggest advantages compared with newer headless platforms. github.comgithub.comwww.wpbundle.com

But if your goal is:

"I'm building my own dropshipping infrastructure and want the commerce engine to bend around my architecture."

I'd pick Medusa.

My recommendation

For the specific thing you're describing:

🥇 Medusa + Next.js + PostgreSQL + your own supplier integration service

I'd choose that unless you have a specific reason to prefer Python/GraphQL.

A sensible stack would be:

Frontend
Next.js
   │
Commerce
Medusa
   │
Database
PostgreSQL
   │
────────────────────────────
Custom integration services
   │
   ├── Supplier APIs
   ├── Product ingestion
   ├── Inventory synchronization
   ├── Price synchronization
   ├── Order routing
   ├── Supplier purchasing
   ├── Tracking synchronization
   └── Webhooks
────────────────────────────
Infrastructure
Docker
Redis
Object storage
Queue/workers

The key design decision: don't make Medusa directly responsible for every supplier. Make your own supplier abstraction layer the source of truth for supplier behavior. That makes adding your 10th, 50th, or 100th supplier dramatically easier.

If you're building this from scratch, I'd seriously consider Medusa vs. Vendure specifically rather than comparing 15 platforms—the two are particularly well suited to a TypeScript-heavy, highly customized dropshipping system.

Yes. If your goal is “I want to own the store, database, checkout logic, supplier integrations, order routing, and basically every workflow”, I’d look at headless open-source commerce frameworks, rather than traditional hosted platforms.

My ranking for a custom dropshipping operation

1. Medusa — my first choice

For the specific model you're describing, I'd start with Medusa.

It's an open-source, MIT-licensed commerce platform designed as a customizable commerce engine rather than a Shopify-style SaaS. Its modules cover things like products, carts, orders, payments, fulfillment and inventory, while allowing you to build your own commerce logic around them. github.com

The architecture is particularly attractive for dropshipping because you can make your own integrations such as:

                 YOUR STOREFRONT
                 Next.js / React
                       │
                       ▼
                ┌─────────────┐
                │   MEDUSA    │
                │   COMMERCE  │
                └──────┬──────┘
                       │
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
   Supplier API    Payment API    Shipping API
        │
   ┌────┴────┐
   ▼         ▼
Supplier A  Supplier B
   │         │
   └────┬────┘
        ▼
  Order routing engine

You could build your own supplier abstraction:

SupplierAdapter
├── getProduct()
├── getInventory()
├── createOrder()
├── getOrderStatus()
├── getTracking()
├── cancelOrder()
└── syncPrices()

Then Amazon, AliExpress, CJ, private suppliers, wholesalers, your own warehouse, etc. can all sit behind the same interface.

That is much more interesting for dropshipping than simply installing a dropshipping plugin.

Medusa is also TypeScript/Node-based, so if your custom integrations are going to be primarily APIs, webhooks, queues and server-side JavaScript/TypeScript, it's a very comfortable stack. github.com

2. Vendure — arguably better for complicated business rules

Vendure is another excellent option.

Its big differentiator is its plugin-first architecture. You can extend or override functionality through plugin contracts instead of modifying/forking the core. It uses TypeScript, Node.js, NestJS and GraphQL. github.com

I'd seriously consider Vendure if your eventual system looks like:

“I don't just want a store. I want to build a proprietary commerce/fulfillment platform.”

For example:

Customer
   ↓
Storefront
   ↓
Vendure
   ↓
Order orchestration
   ├── Supplier selection
   ├── Supplier inventory
   ├── Margin calculation
   ├── Fraud checks
   ├── Payment
   ├── Fulfillment
   └── Tracking

Vendure's plugin architecture is particularly useful if you expect those rules to become complicated. github.com

I'd pick Vendure over Medusa if your engineering team strongly prefers NestJS/GraphQL and expects lots of custom domain logic.

3. Saleor — excellent if API-first is your priority

Saleor takes an even more headless approach.

It's GraphQL-native and API-only, with extensibility through webhooks, apps, metadata and API extensions. It also has native concepts around channels, currencies, warehouses, products, payments, shipping and promotions. github.comsaleor.io

This is attractive if you envision:

              ┌── Web Store
              │
              ├── Mobile App
              │
              ├── TikTok/Marketplace
              │
              ├── Internal Admin
              │
              └── AI Shopping Agent
                       │
                       ▼
                  SALEOR API
                       │
             ┌─────────┼─────────┐
             ▼         ▼         ▼
          Payments  Suppliers  Fulfillment

Saleor is particularly compelling when you're building a multi-channel commerce system, rather than just one storefront.

Its core is open source, and you can self-host it; the project explicitly positions itself around integrating with anything and owning your stack. github.comsaleor.io

4. Sylius — great if you're a PHP/Symfony shop

Sylius is an open-source Symfony-based ecommerce framework with a strong emphasis on building highly customized commerce applications. Its REST API makes integrations straightforward, and the core is MIT licensed. github.com

I'd choose it if you already have serious PHP/Symfony expertise.

I wouldn't choose it over Medusa/Vendure solely for a new dropshipping project if your team is equally comfortable with both ecosystems.

What I'd actually build for your use case

If you're serious about custom integrations, I wouldn't think of this as:

“Which open-source Shopify alternative should I install?”

I'd think of it as:

“Which commerce engine should become the core of my own dropshipping infrastructure?”

My preferred architecture would be:

                    Next.js
                       │
                       ▼
                 ┌───────────┐
                 │   Medusa  │
                 └─────┬─────┘
                       │
          ┌────────────┼─────────────┐
          ▼            ▼             ▼
      PostgreSQL      Redis       Search
                                     
                       │
                       ▼
             ┌─────────────────┐
             │ Integration     │
             │ Layer           │
             └────────┬────────┘
                      │
        ┌─────────────┼──────────────┐
        ▼             ▼              ▼
   Supplier API   Supplier API   Supplier API
        │             │              │
        ▼             ▼              ▼
     Supplier A    Supplier B    Supplier C

                      │
                      ▼
                Order Router
                      │
          ┌───────────┼───────────┐
          ▼           ▼           ▼
      Fulfillment   Tracking    Returns

Then I'd make supplier integration its own service, rather than embedding every supplier directly into the commerce platform.

That gives you the ability to do things like:

• automatically select the cheapest supplier
• switch suppliers when inventory disappears
• calculate landed cost
• enforce minimum margins
• synchronize supplier inventory
• synchronize prices
• automatically place supplier orders
• normalize tracking numbers
• detect supplier failures
• split an order across suppliers
• create your own supplier dashboard
• add suppliers without changing the storefront
• eventually build your own supplier network

That's where open source really starts paying off.

My recommendation

If I were starting this project today:

🥇 Medusa — best balance of flexibility, developer experience and modern commerce primitives.
🥈 Vendure — pick this if complex custom business workflows/plugins are the centerpiece.
🥉 Saleor — pick this if you're building a highly API-driven, multi-channel system and like GraphQL/Python.

I would not start with WooCommerce for the architecture you're describing unless speed-to-market and its enormous plugin ecosystem are more important than having a clean custom backend.

If you tell me what suppliers/marketplaces you want to integrate (e.g. AliExpress, CJ, Amazon, Printful, private wholesalers, Shopify, TikTok Shop, eBay, etc.), I can narrow this down to the best architecture and show you exactly how I'd structure the APIs, database, order-routing engine, and supplier adapter layer.