What is a headless commerce platform?

A headless commerce platform separates the commerce backend and APIs from the storefront, so any frontend (web, mobile, POS, in-store) reads from one system through an API. Vendure is an open-source headless commerce platform that ships the whole commerce domain as one application: catalogue, customers, orders, payments, promotions, and the Admin Dashboard, served over GraphQL Admin and Shop APIs. Unlike most headless commerce solutions, you don't assemble it from separate services, and one core runs B2B, B2C, and mixed models. It's also called headless commerce software or a headless ecommerce platform; the idea is the same: one extensible backend, any frontend.

Does the Admin Dashboard ship with Vendure?

Yes. The Admin Dashboard is part of Vendure Core and is the same operator interface our customers run in production today. It inherits the same extension model as the backend: custom fields and custom entities surface automatically, plugins extend it with their own views, and every action is role-scoped through the same permissions system. See Vendure Core for the full scope.

Can I get to production on Vendure Core alone?

Yes. The same code on GitHub is the code running production commerce today, including at IBM, Munch, SKYdeals, and Hans Kohler. There is no separate "production build" you can't see. You can self-host Core to production, or run it on Vendure Cloud as a managed runtime if you'd rather not operate the infrastructure yourself. See the case for open source at enterprise scale .

How is the data model laid out?

One unified data model exposed through two GraphQL APIs, the structural core of any credible headless commerce platform. Products, variants, customers, orders, payments, shipments, taxes, promotions, and channels are all first-class entities in a single SQL database. The full schema is in the docs .

Yes. Core is stateless at the application layer, scales horizontally behind any load balancer, and uses a SQL database for durable storage. Job processing runs as separate worker processes you can scale independently. See Vendure Core for the volume proof and production case studies.

Headless commerce platform

The headless commerce platform and Admin Dashboard, shipped as one

Vendure is one coherent headless commerce platform: the backend that runs your store and the Admin Dashboard your team operates it from. Both are built to be extended at the core, so you start with a working system, not an assembly project.

Compare editions Talk to an engineer

Vendure Core

one application

BackendThe server that runs your store

Data modelone schema

OrdersCustomers · Payments

CustomersOrders · Addresses

ProductsVariants · Assets

PromotionsConditions · Actions

PaymentsOrders · Refunds

ChannelsCatalog · Pricing

Runtime

Admin API

Shop API

Worker + jobs

SQL Database

Admin DashboardThe UI your team operates it from

Orders+ New

OrderCustomerStatusTotal

#10248Acme CorpPaid$1,240

#10247GlobexPending$860

#10246InitechShipped$2,310

#10245UmbrellaPaid$540

#10244SoylentPaid$1,990

#10243Wonka IncShipped$720

#10242Stark IndustriesPaid$3,180

#10241Wayne CoRefunded$410

one data model

Most headless platforms ship you the parts

Most headless commerce solutions hand you a DIY composable stack: best-of-breed primitives and a parts list. A catalogue service here, an order service there, a pricing API somewhere else. Every integration, release, and outage is yours to own, across as many vendors as you assembled.

Vendure ships the commerce domain as one application, with one data model. Orders know about customers. Customers know about prices. Prices know about taxes. The wiring is already there because it's the same codebase. The Admin Dashboard ships with it, built on the same model and included by default. A headless commerce platform should ship the full commerce domain, already connected. Vendure does.

What's in the box

Everything a headless commerce platform should ship, already wired

The full commerce domain, shipped as first-class entities and APIs in one headless commerce backend, with the Admin Dashboard your team uses to run it. One core runs B2B, B2C, and mixed models, with advanced B2B capabilities in Vendure Platform built on the same extension model that powers the backend and dashboard together.

Catalogue, variants, facets, collections

Products, variants, options, assets, facets, and collections. Channels-aware out of the box. The catalogue layer your storefront and search index both read from, not three duplicated stores you have to keep in sync.

Customers, carts, orders, checkout

Anonymous and registered customers, customer groups, durable carts, the full order lifecycle, and a checkout state machine. The buyer side of the database that every other service in your stack would otherwise have to invent.

Payments, shipping, taxes, fulfilment

Payment method strategies, shipping calculators, tax zones and rates, fulfilment handlers. Pluggable where they need to be, with defaults that work, so day one isn't a tax-engine integration project.

Promotions engine

Conditions, actions, stacking rules, coupon codes, customer-group eligibility. The promotions engine your merchandising team expects, not a hook that fires into your own discount service.

Admin API and Shop API

Two GraphQL surfaces over the same data model. The Admin API is role-permissioned for operators and integrations. The Shop API is scoped for buyer-side traffic. Same entities, different lenses.

Admin Dashboard, built in

A production admin UI for catalogue, orders, customers, promotions, and channels, shipped as part of Vendure. Custom fields and entities surface automatically, plugins add their own views, and every screen respects role-scoped permissions.

Worker and job processing

Durable background jobs for inventory updates, email sends, search reindexing, and webhooks. A first-class job runner you scale separately from the API, not a cron file glued to the side.

Durable SQL storage

PostgreSQL, MySQL, or MariaDB. The database your ops team already runs, with the backup, replication, and observability story they already know.

One data model behind the backend, the dashboard, and the APIs

When pricing changes, the storefront sees it because the storefront is reading the same prices the admin set in the dashboard. When an order moves state, the warehouse integration sees it on the same event the dashboard reacts to.

Add a custom field once. It shows up in the GraphQL schema, the database, the TypeScript types, and the Admin Dashboard, without extra wiring.

One place to change something and have it propagate everywhere it matters. Most headless commerce platforms ask you to wire that yourself. Vendure ships the wire.

What convinced me about Vendure is its fundamentally well-architected codebase. It's clear, intuitive, and easy to extend, making it adaptable to virtually any use case.