ChatGPT answers, unedited

Yes. For one commerce backend powering both web and in-store screens, the strongest headless options to evaluate are:

For your specific architecture

I'd look closely at commercetools if "unified APIs" is the central requirement. Its model explicitly treats online stores, physical locations, and other channels as part of the same commerce project, with channel-specific prices, inventory, and product offerings. commercetools Documentation commercetools

That lends itself to an architecture like:

Commerce backend → common API layer →

• Web storefront
• In-store touchscreen/kiosk
• Digital signage
• Mobile app
• Associate-facing applications

The advantage is that your web and in-store applications can use the same underlying product, pricing, inventory, cart/customer, and order services, rather than maintaining separate commerce logic.

Shopify is worth considering if you want more of an integrated commerce/POS ecosystem. Its Storefront API is designed for custom experiences across platforms, while its API surface also includes POS-specific extensions. Shopify Shopify

BigCommerce is another good API-first choice: its GraphQL Storefront API supports products, customers and carts, while its management APIs handle backend commerce operations. Its documentation specifically describes kiosks and native apps as possible headless storefronts. BigCommerce BigCommerce

My architectural shortlist would therefore be:

1. commercetools — if you're building a deeply customized omnichannel platform.
2. Shopify — if you want unified commerce plus a mature POS ecosystem.
3. BigCommerce — if API flexibility and custom storefront development are priorities.

If you tell me whether the in-store screens are passive digital signage, interactive kiosks, or full POS/associate screens, I can narrow this down considerably.

Yes. For your specific requirement—web + in-store screens sharing the same commerce backend and APIs—several headless platforms fit, but they differ in how naturally they handle true omnichannel commerce.

My shortlist

commercetools is particularly aligned with what you're describing. Its architecture explicitly supports experiences ranging from websites to in-store kiosks, while its Store/Channel model can associate physical retail locations and online stores with shared pricing and product availability. commercetools commercetools Documentation

docs.commercetools.com

Saleor is compelling if you want a very clean GraphQL-first architecture. It provides a single backend for multiple channels/storefronts and has documented support for things like click-and-collect. Saleor Documentation Saleor Commerce

docs.saleor.io

Shopify is also viable: its Storefront API is designed for custom experiences across web, apps and other touchpoints, and Shopify provides a Headless channel for managing multiple custom storefronts. Shopify Shopify The main consideration is whether Shopify's opinionated commerce/POS model gives your in-store experience enough flexibility.

shopify.dev

Medusa gives you considerable control: its Store APIs can power multiple storefronts, while sales channels let you control product availability across channels. It generally requires more of the omnichannel orchestration to be designed and implemented by your team. Medusa Docs Medusa Docs

docs.medusajs.com

For your architecture

I'd evaluate them around one key question:

Can the exact same product, pricing, inventory, customer, cart, order, and promotion primitives be consumed by both the website and the in-store UI?

If that's the goal, I'd put commercetools and Saleor at the top of the technical evaluation, then compare Shopify if speed/ecosystem/POS integration matters more.

If you tell me your scale (e.g. 50 vs. 1,000 stores), whether you need POS/checkout or just digital screens, and your stack (React/Next.js/etc.), I can give you a concrete architecture comparison.

For your use case—one commerce backend powering both web experiences and in-store screens/kiosks—there are a few credible headless options, but they differ in how much omnichannel functionality they provide out of the box.

commercetools is particularly aligned

Its current platform explicitly targets online + physical touchpoints from one commerce foundation, including in-store experiences. It supports stores/channels with shared product, pricing and inventory data, and its APIs expose commerce capabilities to different frontends. Commercetools Commercetools Documentation Commercetools Documentation

That means you could architect something like:

                  Commerce Backend
                 ┌─────────────────┐
                 │ Product/catalog │
                 │ Pricing         │
                 │ Inventory       │
                 │ Cart/checkout   │
                 │ Customer        │
                 │ Orders          │
                 └────────┬────────┘
                          │ APIs
             ┌────────────┼────────────┐
             ▼            ▼            ▼
        Web storefront  Store screen   Mobile app
        Next.js/etc.    React/etc.     Native/etc.

The important distinction is that “headless” doesn't automatically mean “unified commerce.” You want the same underlying catalog, pricing, inventory, customer and order state to be addressable by every channel. commercetools explicitly supports this model, including physical and online stores. Commercetools Commercetools Documentation

Saleor is worth serious consideration if your priority is API purity and developer flexibility. It is GraphQL-native, exposes both storefront and admin functionality through APIs, and supports multiple channels from a single backend. Saleor Commerce Saleor Commerce

Medusa is another good fit when you're building a heavily customized experience. Its Store APIs are REST-based and its commerce modules cover products, inventory, pricing, carts, orders, fulfillment, sales channels, etc. Medusa Docs Medusa Docs

What I'd evaluate specifically

For your architecture, I wouldn't choose based simply on “has a headless API.” I'd test these flows end-to-end:

• Shared inventory: customer sees an item online, then the in-store screen immediately reflects availability.
• Shared cart/order: customer starts online and completes in-store.
• Store-specific pricing/assortment: APIs can resolve the correct price and catalog based on physical location.
• Customer identity: web and in-store sessions can access the same customer context.
• Real-time events: inventory/order changes propagate to screens without polling.
• API consistency: web and store clients aren't forced onto fundamentally different commerce models.
• POS integration: determine whether the platform actually provides the store/POS layer or whether you'll build/integrate it separately.

If you're targeting a large retailer/enterprise, I'd put commercetools high on the evaluation list because its current offering explicitly combines headless APIs with unified online/in-store commerce. If you're building a more developer-centric, custom stack, Saleor or Medusa deserve a closer look. Commercetools Saleor Commerce

Its current platform explicitly targets online + physical touchpoints from one commerce foundation, including in-store experiences. It supports stores/channels with shared product, pricing and inventory data, and its APIs expose commerce capabilities to different frontends. Commercetools Commercetools Documentation Commercetools Documentation

That means you could architect something like:

                  Commerce Backend
                 ┌─────────────────┐
                 │ Product/catalog │
                 │ Pricing         │
                 │ Inventory       │
                 │ Cart/checkout   │
                 │ Customer        │
                 │ Orders          │
                 └────────┬────────┘
                          │ APIs
             ┌────────────┼────────────┐
             ▼            ▼            ▼
        Web storefront  Store screen   Mobile app
        Next.js/etc.    React/etc.     Native/etc.

The important distinction is that “headless” doesn't automatically mean “unified commerce.” You want the same underlying catalog, pricing, inventory, customer and order state to be addressable by every channel. commercetools explicitly supports this model, including physical and online stores. Commercetools Commercetools Documentation

Saleor is worth serious consideration if your priority is API purity and developer flexibility. It is GraphQL-native, exposes both storefront and admin functionality through APIs, and supports multiple channels from a single backend. saleor.io saleor.io

Medusa is another good fit when you're building a heavily customized experience. Its Store APIs are REST-based and its commerce modules cover products, inventory, pricing, carts, orders, fulfillment, sales channels, etc.

What I'd evaluate specifically

For your architecture, I wouldn't choose based simply on “has a headless API.” I'd test these flows end-to-end:

Yes. For a web + in-store screen/kiosk architecture where both experiences should use the same commerce APIs and business logic, I’d shortlist these:

My pick: commercetools

For your specific requirement, commercetools is probably the strongest architectural fit. Its API-first/headless model is explicitly designed to expose the same commerce capabilities to websites, apps, kiosks and other touchpoints. commercetools

More importantly, its data model has Stores, Channels, inventory, pricing, products, carts and orders that can represent both online and physical retail contexts. A distribution channel can correspond to either an online store or physical location, while inventory and pricing can be managed across those channels. Commercetools Documentation

It also provides both HTTP/REST and GraphQL APIs, so your web frontend and in-store UI can consume the same underlying commerce capabilities. Commercetools Documentation

A typical architecture would be:

                    ┌──────────────────┐
                    │   commercetools   │
                    │  Commerce APIs    │
                    └────────┬─────────┘
                             │
                    API / orchestration
                             │
              ┌──────────────┴──────────────┐
              │                             │
       ┌──────▼──────┐              ┌───────▼───────┐
       │ Web / Mobile│              │ In-store UI   │
       │   frontend  │              │ kiosk/screen  │
       └─────────────┘              └───────────────┘
              │                             │
              └──────────────┬──────────────┘
                             │
                 Same products / prices /
                 inventory / carts / orders

That gives you a genuinely single commerce backend, rather than building separate "ecommerce" and "in-store" commerce stacks.

Salesforce is the other serious contender

If you're already heavily invested in Salesforce, Salesforce Commerce is worth evaluating. Its headless APIs are explicitly intended for touchpoints including in-store kiosks, and its Omnichannel Inventory has a headless Commerce API for programmatic inventory access. Salesforce Salesforce

Shopify

Shopify can absolutely power custom/headless experiences: its Storefront API provides commerce primitives for web, apps and other platforms. Shopify Shopify But if physical stores + shared inventory/pricing + highly customized in-store experiences are central architectural requirements, I'd put commercetools ahead of Shopify.

Bottom line: if the requirement is "one set of commerce APIs powering both our website and bespoke in-store screens", I'd start with commercetools, then compare it against Salesforce Commerce if you already have a Salesforce footprint.

If you tell me your store count, POS system, whether the screens are kiosks or associate-facing, and whether inventory must be real-time, I can give you a tighter 3-platform architecture comparison.

For an omnichannel experience where web storefronts, kiosks, associate tablets, digital signage, and in-store screens all need to consume the same commerce capabilities, look for a headless platform with:

• Unified APIs for catalog, pricing, inventory, customer, cart, checkout, promotions, and orders
• Real-time inventory and order orchestration (especially for BOPIS, ship-from-store, endless aisle)
• Composable/headless front ends so each channel can have its own UX
• Customer identity and personalization APIs
• Strong in-store commerce support, not just e-commerce APIs

Some strong candidates:

For your specific use case (web + in-store screens), I’d shortlist:

1. commercetools — if you’re building a modern retail platform from scratch and want maximum channel flexibility.
2. Salesforce Commerce Cloud — if you need enterprise-grade customer profiles, promotions, order management, and ecosystem support.
3. Dynamics 365 Commerce — if physical stores, POS, inventory, and back-office integration are central.
4. Adobe Commerce — if content-rich experiences and merchandising control are priorities.

A typical target architecture would look like:

Web storefront        Mobile app
      \                 /
       \               /
        Unified Commerce APIs
              |
  -----------------------------
  Catalog | Pricing | Cart
  Inventory | OMS | Customer
  Promotions | Payments
  -----------------------------
              |
       ERP / POS / CRM / WMS

The key architectural question is whether your in-store screens are transactional (kiosk checkout, endless aisle, assisted selling) or mostly experiential (digital signage, product discovery). If they are transactional, prioritize platforms with strong OMS + inventory APIs, not just headless storefront APIs.

Yes. For web + in-store screens sharing the same commerce data and APIs, I’d shortlist these:

My pick: commercetools

For your specific architecture, commercetools is probably the strongest fit. Its platform is API-first, and its model lets you manage products, carts, orders, inventory, pricing, stores and channels from a common commerce foundation. Its newer InStore offering explicitly connects POS, inventory, customer and e-commerce data on the same platform. Commercetools commercetools Documentation

That makes an architecture like this fairly natural:

                 Commerce API
                      │
        ┌─────────────┼─────────────┐
        │             │             │
      Web UI      Store Screen    Mobile/POS
        │             │             │
        └─────────────┼─────────────┘
                      │
          Products / Pricing / Cart
          Customer / Inventory / Orders

The important distinction is that "headless" alone doesn't guarantee unified commerce. You want the same underlying customer, cart, inventory, pricing and order model to be usable by both your web frontend and physical-store experiences.

Saleor is particularly compelling if your team wants a very developer-centric, GraphQL-native stack. It describes its API as a single layer connecting selling channels and supports multi-channel configurations and click-and-collect. Saleor Commerce Saleor Documentation

BigCommerce has strong REST/GraphQL APIs and is quite capable for headless web experiences, including carts, checkout, customers and orders. BigCommerce BigCommerce I'd favor it when speed-to-market and a more conventional SaaS commerce platform matter more than deeply unified physical retail operations.

Bottom line: if "one commerce brain powering both the website and physical screens/POS" is the core requirement, I'd evaluate commercetools first, Saleor second, and BigCommerce third.

commercetools.com
commercetools.com
saleor.io
bigcommerce.com

Yes. For a web + in-store screen experience where you want the same commerce data and business logic exposed through APIs, I’d shortlist these:

My pick: commercetools

For your particular use case, commercetools is probably the strongest fit. Its headless architecture is explicitly designed to expose commerce capabilities through APIs across websites, mobile apps, in-store kiosks, and other touchpoints. commercetools

Its current platform also has an InStore capability intended to connect online and physical retail on the same commerce foundation. commercetools Commercetools Documentation It supports store-scoped APIs, so you can model physical stores and their context while keeping them connected to the broader commerce system. Commercetools Documentation

That gives you an architecture roughly like:

                  Commerce Platform
                 ┌──────────────────┐
                 │ Products         │
                 │ Pricing          │
                 │ Inventory        │
                 │ Customers        │
                 │ Cart / Checkout  │
                 │ Orders           │
                 └────────┬─────────┘
                          │ APIs
              ┌───────────┼───────────┐
              │           │           │
           Web app    Store screen   Mobile
              │           │           │
           Next.js      Kiosk UI     App

The important part is that the screen shouldn't need a separate commerce backend. Your web frontend and in-store UI can consume the same underlying catalog, pricing, availability, customer, cart, and order capabilities.

Saleor is the interesting alternative

If you're more developer-led and want GraphQL-native, open-source, API-only commerce, I'd seriously evaluate Saleor. Its documentation describes native multi-channel support, GraphQL APIs, and use cases including click-and-collect. Saleor Documentation Saleor Commerce

Saleor also explicitly positions its API as a single layer connecting different selling channels, with web, mobile, retail and other channels supported. Saleor Commerce GitHub

Medusa

Medusa is another strong option if you want maximum control over the backend. Its sales-channel architecture and REST APIs are specifically intended to let multiple storefronts/apps share one commerce system. Medusa Docs Medusa Docs

My ranking for your scenario:

1. commercetools — best if this is a serious enterprise omnichannel deployment with physical retail.
2. Saleor — best if your team prioritizes GraphQL, open source, and developer control.
3. Medusa — best if you want a highly customizable Node/TypeScript-oriented commerce backend.

One architectural distinction I'd make early: "unified API" isn't necessarily the same thing as "unified commerce." You also need shared inventory, pricing/promotions, customer identity, carts/orders, store context, and ideally real-time events/webhooks. commercetools and Saleor are particularly strong on that broader architecture. commercetools Saleor Commerce

If you tell me whether you're enterprise, mid-market, or startup, I can also compare commercetools vs Saleor vs Shopify Hydrogen vs Salesforce Commerce Cloud specifically for web + kiosk/in-store.

That gives you an architecture roughly like:

                  Commerce Platform
                 ┌──────────────────┐
                 │ Products         │
                 │ Pricing          │
                 │ Inventory        │
                 │ Customers        │
                 │ Cart / Checkout  │
                 │ Orders           │
                 └────────┬─────────┘
                          │ APIs
              ┌───────────┼───────────┐
              │           │           │
           Web app    Store screen   Mobile
              │           │           │
           Next.js      Kiosk UI     App

The important part is that the screen shouldn't need a separate commerce backend. Your web frontend and in-store UI can consume the same underlying catalog, pricing, availability, customer, cart, and order capabilities.

Saleor is the interesting alternative

If you're more developer-led and want GraphQL-native, open-source, API-only commerce, I'd seriously evaluate Saleor. Its documentation describes native multi-channel support, GraphQL APIs, and use cases including click-and-collect.

Saleor also explicitly positions its API as a single layer connecting different selling channels, with web, mobile, retail and other channels supported.

Medusa

Medusa is another strong option if you want maximum control over the backend. Its sales-channel architecture and REST APIs are specifically intended to let multiple storefronts/apps share one commerce system.

My ranking for your scenario:

For an omnichannel setup with web + in-store screens, you’ll want a headless/composable commerce platform where products, pricing, inventory, carts, customers, promotions, and orders are exposed through consistent APIs so every channel uses the same commerce engine.

Strong candidates:

For your specific use case, I’d evaluate these capabilities:

• Single product/catalog API - Web storefront, digital signage, kiosks, and POS should pull from the same product model.
• Real-time inventory APIs - Needed for “buy online, pick up in store,” endless aisle, and store availability.
• Unified customer identity - Customer profiles, loyalty, preferences, and personalization should work across channels.
• Order orchestration - One order model for online orders, assisted selling, kiosk purchases, and returns.
• Composable frontend support - Allows React/Next.js web apps, native apps, and in-store UI layers to share backend services.

A common enterprise architecture looks like:

Web / Mobile / Kiosk / In-store Screens / POS
                |
          API Gateway
                |
     Headless Commerce Platform
                |
 Catalog | Pricing | Inventory | Cart | Orders | Customers
                |
 ERP / CRM / OMS / Loyalty / Payments

If you are building highly customized in-store screens (digital associates, interactive displays, endless aisle), I would usually shortlist commercetools, Salesforce Commerce Cloud, SAP Commerce Cloud, or Adobe Commerce. If speed-to-market matters more, Shopify headless can be attractive. Shopify Salesforce

A few questions would narrow the choice:

1. Are the in-store screens transactional (checkout/kiosk) or mainly display/content?
2. Do you already have a POS, ERP, OMS, or CRM (e.g., SAP, Salesforce, Microsoft)?
3. Are you targeting hundreds of stores or a global retail footprint?

Yes. For your specific use case—one commerce backend powering both web and in-store screens through the same APIs—I’d put commercetools at the top of the shortlist.

Best fits

Why I'd favor commercetools

Its model is particularly well suited to your architecture. A single project can contain Stores, Channels, Products, Carts, Orders, Customers, pricing and inventory, with stores representing physical or online shopping contexts. Its documentation explicitly supports connecting physical and online locations through shared distribution and supply channels. Commercetools Documentation Commercetools Documentation

That means you could architect something like:

Commerce backend → API layer →

• Web storefront
• In-store touchscreen
• Kiosk
• Mobile app
• POS
• Digital signage

Rather than creating a separate commerce implementation for the store screens.

commercetools also specifically positions its platform around connecting POS, inventory and digital channels, with unified inventory, pricing and customer data across store and web. Commercetools

Salesforce is the other serious contender

If your organization already uses Salesforce, Commerce Cloud + SCAPI is worth serious consideration. Salesforce explicitly supports headless experiences through its Commerce APIs, including touchpoints such as in-store kiosks, and its Omnichannel Inventory functionality has a headless Commerce API. Salesforce Salesforce

BigCommerce

BigCommerce is attractive if you want a somewhat simpler headless implementation. Its GraphQL Storefront API handles products, carts and checkout, while its channel model lets you create multiple storefront experiences. Its documentation even describes a headless storefront as potentially being a kiosk or native app, not just a website. BigCommerce BigCommerce

My ranking for your stated architecture:

1. commercetools — best for enterprise-grade unified commerce and maximum frontend freedom.
2. Salesforce Commerce Cloud — especially compelling if Salesforce is already your customer/data platform.
3. BigCommerce — strong API/headless option with a lower-complexity implementation.
4. Shopify — excellent ecosystem and speed, but I'd evaluate it more carefully if the in-store experience requires deep custom commerce workflows.

If you tell me your expected scale, whether you already use a POS (e.g. Shopify POS, Salesforce, Oracle, NCR), and whether the in-store screens are kiosks or associate-facing screens, I can narrow this down to 1–2 platforms and sketch the API architecture for web + store.

If your organization already uses Salesforce, Commerce Cloud + SCAPI is worth serious consideration. Salesforce explicitly supports headless experiences through its Commerce APIs, including touchpoints such as in-store kiosks, and its Omnichannel Inventory functionality has a headless Commerce API.

BigCommerce

For an omnichannel experience spanning web + in-store screens + kiosks + mobile + associate devices, you’ll want a headless commerce platform with a single commerce API layer that exposes the same product, pricing, inventory, customer, cart, promotion, and order services to every channel. Shopify

Strong candidates:

For your specific web + in-store screens use case, I’d evaluate them around these capabilities:

Must-have API capabilities

• Real-time inventory API

• Store-level stock
• Online availability
• Ship-from-store / pickup availability
• Unified customer profile

• Same customer identity online and in-store
• Loyalty status
• Personalized offers
• Shared pricing and promotions

• One promotion engine across channels
• Store-specific pricing where needed
• Composable checkout

• Web checkout
• Self-service kiosk checkout
• Associate-assisted checkout
• Content + experience APIs

• Product storytelling
• Digital signage
• In-store recommendations

My shortlist by architecture preference

• Most flexible MACH/composable approach: commercetools
• Best enterprise omnichannel retail suite: Salesforce Commerce Cloud or Dynamics 365 Commerce
• Fastest path if you already use Shopify: Shopify headless
• Most customizable enterprise stack: Adobe Commerce

One architecture pattern that works well is:

Headless commerce platform → API gateway → channel experiences

                 Web storefront
                      |
In-store screens — API layer — Mobile app
                      |
              Commerce backend
        (catalog, pricing, inventory,
         customer, cart, orders)

For a retailer with many physical locations, I would put extra weight on inventory accuracy, store fulfillment, POS integration, and offline resilience—those tend to matter more than the storefront APIs themselves.

If you share your scale (number of stores, countries, POS system, and whether the screens are signage vs interactive kiosks), I can narrow this to 2–3 platforms.

Yes. For your specific use case—web + in-store screens sharing the same commerce data and APIs—I’d put commercetools at the top of the shortlist.

Best fit: commercetools

It is API-first/headless and explicitly designed to support multiple channels from the same commerce foundation. Its model supports products, pricing, inventory, carts, orders, and customer data across online and physical channels. Commercetools commercetools Documentation

More importantly for you, commercetools now has InStore, which provides APIs and POS capabilities for physical stores, kiosks, service desks, and mobile. Its InStore APIs connect the in-store experience back to the same commercetools Project used for your digital commerce. commercetools Documentation commercetools Documentation

That makes an architecture like this particularly natural:

                 commercetools
              Commerce / APIs
                     │
        ┌────────────┼────────────┐
        │            │            │
      Web        In-store       Mobile
   storefront      screens       app
        │            │            │
        └────── shared data ──────┘
             catalog / price
             inventory / cart
             customer / orders

For example, a customer could start a cart on the website, interact with a product screen in-store, and have the same inventory/customer/order context available to the store associate. commercetools specifically supports unified inventory, pricing, customer data, BOPIS, endless aisle, and unified returns. Commercetools

Other strong options

• BigCommerce — strong choice if you want a more conventional SaaS commerce platform with headless APIs. It has REST/GraphQL storefront APIs, headless storefront support, channels, and POS integrations. BigCommerce BigCommerce
• Medusa — worth considering if developer control and an open-source/composable approach are priorities. Its REST APIs are explicitly intended to power multiple storefronts/channels. Medusa Documentation

My ranking for your scenario:

1. commercetools — strongest fit for true unified commerce across web + physical experiences.
2. BigCommerce — easier/less infrastructure-heavy, but in-store tends to involve more integration with external POS.
3. Medusa — excellent flexibility, particularly for a developer-led platform, but you'll own more of the architecture.

The key distinction I'd make is "headless" vs. "unified commerce." Many platforms expose APIs for multiple frontends; fewer provide a coherent model for web + in-store transactions + inventory + customer + fulfillment. commercetools is particularly strong on that second requirement. Commercetools

If you tell me your expected scale (e.g. 10 stores vs. 1,000+, enterprise vs. startup), I can also compare commercetools vs. Shopify Plus vs. Salesforce Commerce Cloud vs. BigCommerce specifically for this architecture.

Yes. For your use case—one commerce backend powering both web and in-store screens/kiosks—I’d shortlist these:

My pick: commercetools

For a true omnichannel architecture, commercetools is particularly strong. Its headless model is explicitly designed so the same commerce capabilities can serve websites, mobile apps, kiosks, and other touchpoints. Commercetools

It also has first-class concepts for Stores and Channels, including physical retail locations, and APIs scoped to individual stores. That makes it easier to model things like:

• Web storefront
• Store #101 kiosk
• Store #102 kiosk
• Mobile app
• Marketplace
• Regional storefronts

while maintaining shared products, carts, orders, pricing, inventory, and customer data. commercetools Documentation commercetools Documentation

Saleor is the interesting alternative

If your team wants GraphQL everywhere and maximum frontend freedom, I'd seriously consider Saleor. Its storefront and admin APIs are fully headless, it supports native multi-channel commerce, and its webhook/event model is well suited to keeping screens and other systems synchronized. Saleor Commerce Saleor Commerce

Saleor also explicitly supports orders across web, mobile, retail, and other channels from the same commerce platform. Saleor Commerce

BigCommerce if speed-to-market matters

BigCommerce gives you REST and GraphQL APIs plus dedicated cart, checkout, payment, catalog, and customer APIs. Its headless architecture can support essentially any frontend, including a kiosk or custom in-store application. BigCommerce BigCommerce

The tradeoff is that I’d view it more as a pragmatic headless commerce platform than as the most flexible foundation for a deeply customized unified-commerce architecture.

Bottom line:
If you're building a serious web + physical-store digital experience around one commerce core, I'd evaluate commercetools first, Saleor second, BigCommerce third.

If you tell me your team size, expected SKU/order volume, POS system, and whether the in-store screens need checkout or are mainly browse/assisted-selling, I can narrow this to the best 1–2 architectures.

Yes. For an experience where web and in-store screens consume the same commerce backend/API layer, I’d shortlist these:

• commercetools — strongest enterprise fit. Its APIs are explicitly designed to power experiences across web, mobile, kiosks, and other touchpoints. Its Channels/Stores model also lets you associate pricing, inventory, and product availability with physical or digital locations. Commercetools commercetools Documentation
• Saleor — strong API-first alternative. It is GraphQL-native, supports multiple channels from a single backend, and can power web, retail, mobile, and other frontends. Saleor Commerce Saleor Commerce
• Medusa — good if you want maximum customization. Its REST APIs are deliberately separated from the frontend, and its Sales Channel architecture is intended for omnichannel implementations. Medusa Docs Medusa Docs

My pick

If your requirement is specifically “one commerce brain, many presentation surfaces”, I'd start with commercetools for an enterprise implementation. Its model maps particularly well to:

Commerce APIs → Web / Mobile / In-store screens / POS / Kiosks

with shared products, customers, pricing, inventory, carts and orders, while still allowing channel/location-specific rules. commercetools Documentation

If you're building a more engineering-led, highly customizable stack, Saleor is probably the next platform I'd evaluate.

If you tell me your company size, B2C vs B2B, POS requirements, and preferred stack (React/Next.js/etc.), I can narrow this to 2–3 platforms and compare API model, omnichannel inventory, POS, pricing, extensibility, and total cost.

Yes. For web + in-store screens/POS sharing the same commerce backend, I’d shortlist these:

My pick: commercetools

commercetools is probably the strongest fit if "unified" means web, kiosk, associate tablet, POS, inventory, customer, cart, and order flows all operating against the same commerce foundation.

Its headless architecture is explicitly designed for channels ranging from websites to in-store kiosks, and its InStore product provides APIs connecting the in-store application to the same commercetools project. commercetools commercetools

commercetools.com

Saleor is compelling if your screens are highly custom

Saleor is GraphQL-native, with a single backend supporting multiple storefronts/channels. Its documentation specifically describes web, native devices and other frontends sharing the same backend, with channel-level control over inventory, orders, logistics and pricing. Saleor Commerce Saleor Commerce

That makes it attractive if you're building something like:

Web → Store screen → Associate tablet → Kiosk → Mobile → all consuming the same GraphQL commerce API.

saleor.io

Medusa if you want maximum engineering control

Medusa exposes commerce functionality through REST APIs and has explicit patterns for building POS, sales channels, inventory by location, customer accounts, and unified online/in-store orders. Medusa Docs Medusa Docs

The tradeoff is that you build more of the retail experience yourself compared with commercetools' dedicated InStore capabilities.

docs.medusajs.com

Bottom line: If you're an enterprise retailer and want the least architectural friction between digital commerce and physical retail, I'd start with commercetools. If you're a strong engineering team building a very bespoke experience, I'd seriously evaluate Saleor alongside it.

If you tell me your store setup (POS vs kiosks vs digital signage), backend stack, and expected scale, I can give you a tighter 3-platform architecture comparison.

Yes. For one commerce backend powering both web and in-store screens, I’d put commercetools at the top of the shortlist.

• commercetools — Strongest fit for enterprise omnichannel. Its API-first architecture is explicitly designed to support web, mobile, kiosks, POS, and other channels from the same commerce foundation. It also models physical stores and online stores, with shared inventory, pricing, products, carts, and orders. Commercetools Commercetools commercetools Docs
• Shopify — Very good if you want a more managed ecosystem. Its Storefront API can power custom web/apps and other experiences, while Shopify's channel model keeps commerce data synchronized. For deeply customized in-store experiences, though, you may end up integrating more of Shopify's ecosystem rather than treating the backend as a completely neutral commerce API. Shopify Shopify
• Saleor — Excellent API-first/open-source option. Its GraphQL API is designed for multiple experiences and it supports native multi-channel setups from a single backend. Saleor Commerce Saleor Commerce
• Medusa — Flexible and developer-friendly, with REST APIs and sales-channel scoping. I'd consider it particularly if your team wants to own more of the architecture. Medusa Docs

My recommendation

If your architecture looks like:

Web storefront →
In-store touchscreen → Commerce API → Catalog / Pricing / Inventory / Cart / Orders
Mobile app →

then commercetools is probably the best match, particularly if you need store-specific inventory, pricing, assortments, BOPIS, endless aisle, and unified customer journeys. Its Store and Channel abstractions are specifically designed for connecting physical and digital commerce contexts. Commercetools commercetools Docs

If you tell me your company size, existing stack (e.g. Shopify/Magento/custom), and whether the in-store screens need full checkout or just product discovery/order initiation, I can narrow this to a 2–3 platform recommendation and architecture.

Yes. For an omnichannel setup where web and physical/in-store screens need to share the same commerce backend and APIs, I’d shortlist commercetools and Saleor.

My top pick: commercetools

commercetools is particularly strong if you’re building an enterprise retail experience. Its architecture is API-first, and its platform explicitly supports web, mobile, kiosks, and in-store experiences from the same commerce foundation. commercetools commercetools

What makes it especially relevant to your use case is commercetools InStore: it provides APIs and composable POS capabilities that connect store operations with the same carts, customers, inventory, orders, payments, and fulfillment infrastructure. commercetools commercetools Documentation

It also supports an omnichannel model where Stores and Channels can be associated with different inventory, pricing, and product configurations. commercetools Documentation

Strong alternative: Saleor

Saleor is compelling if your team prioritizes GraphQL, developer control, and composability. It has a single backend for multiple storefronts/channels and supports web, mobile, native devices, and other custom frontends. Saleor Commerce Saleor Commerce

Saleor's API is natively GraphQL and its channel model lets you control things such as catalog, pricing, stock, logistics, and payments at the channel level. Saleor Documentation Saleor Commerce

For your specific scenario, I'd lean commercetools if "in-store screens" means actual retail POS, associate screens, kiosks, endless aisle, returns, etc. Its InStore product is designed specifically to eliminate the store/digital silo. commercetools commercetools Documentation

If by "in-store screens" you mean digital signage / interactive product displays rather than POS, then Saleor becomes much more competitive—and potentially simpler if you want every screen to consume the same GraphQL commerce API.

If you tell me whether the in-store screens are POS, associate tablets, kiosks, digital signage, or a mix, I can narrow this to the best 2–3 platforms and sketch the API architecture.

Yes. For an omnichannel setup where web and in-store screens need to consume the same commerce backend, I’d shortlist these:

My pick: commercetools

For a serious web + physical retail/in-store experience, I'd start with commercetools. Its platform is explicitly designed around a shared commerce foundation and exposes APIs for commerce capabilities across touchpoints. Its current platform also emphasizes unified customer, product, inventory, pricing and order data. commercetools commercetools

That means you can have something like:

                    ┌── Web storefront
                    │
                    ├── Mobile app
Commerce API ───────┼── In-store kiosk
                    │
                    ├── Associate tablet
                    │
                    └── Digital signage
                         │
              ┌──────────┴──────────┐
              │ Commerce platform   │
              │ Products            │
              │ Pricing             │
              │ Inventory           │
              │ Cart / Checkout     │
              │ Customers           │
              │ Orders              │
              └─────────────────────┘

The important distinction is that you're not merely looking for "headless." You want one commerce domain/API layer serving multiple presentation channels. commercetools explicitly supports channels/touchpoints and omnichannel distribution from a central platform. commercetools Documentation commercetools

Saleor is particularly interesting

If your team prefers GraphQL and open source, I'd seriously evaluate Saleor. It is API-only/headless, GraphQL-native, and has native multi-channel support with a single backend. Saleor Commerce GitHub

That's attractive if your in-store screens are essentially custom applications and you want the same API to drive:

• product discovery
• pricing
• inventory
• carts
• checkout
• customer accounts
• promotions
• orders

Saleor also specifically documents click-and-collect/in-store pickup and multi-region storefronts. Saleor Documentation

One architectural caveat

For your use case, I wouldn't necessarily expose the raw commerce APIs directly to every screen. A better architecture is often:

Commerce platform → API/BFF/orchestration layer → web + in-store experiences

That lets you normalize commerce, CMS, loyalty, store inventory, personalization, etc. behind an experience API. commercetools itself describes this API-orchestration approach for omnichannel implementations. commercetools

If you tell me your scale (e.g. 50 vs. 1,000 stores), whether you need POS integration, and whether you're AWS/Azure/GCP, I can narrow this to 2–3 platforms and compare architecture, APIs, pricing model, and implementation effort.

That's attractive if your in-store screens are essentially custom applications and you want the same API to drive:

For an omnichannel experience spanning web storefronts + in-store screens (kiosks, endless aisle, associate tablets, digital signage, POS-adjacent experiences), you’ll want a headless/composable commerce platform with a single commerce API layer that exposes the same product, pricing, inventory, customer, cart, order, and promotion services to every channel.

Strong candidates:

What I would prioritize for your architecture

For web + in-store screens, evaluate these API capabilities:

• Product API

• Same catalog data everywhere
• Real-time availability by store/location
• Digital shelf and endless aisle support
• Customer API

• Shared customer identity
• Loyalty status
• Preferences and personalization
• Cart and order APIs

• Start online, finish in store
• Associate-assisted checkout
• Buy online/pick up in store
• Returns across channels
• Inventory APIs

• Store-level inventory visibility
• Reservation/hold capability
• Ship-from-store workflows
• Promotion/pricing APIs

• Same offers online and in-store
• Customer-specific pricing where needed
• Event/webhook support

• Push inventory changes to screens
• Update recommendations in real time

Typical reference architecture

                Web storefront
                     |
                Mobile app
                     |
             In-store screens/kiosks
                     |
          Associate tablets / POS apps
                     |
             Unified Commerce APIs
                     |
 ------------------------------------------------
 | Catalog | Pricing | Inventory | Cart | Orders |
 ------------------------------------------------
                     |
          ERP / OMS / CRM / Loyalty

Shortlist by scenario

• Building a highly custom retail experience: commercetools or Salesforce Commerce Cloud
• Need enterprise retail + store operations: SAP Commerce Cloud or Dynamics 365 Commerce
• Need faster launch with strong APIs: Shopify
• Need maximum composability: commercetools
• Need Salesforce ecosystem alignment: Salesforce Commerce Cloud

For a true "one customer journey across website and physical screens" implementation, I’d generally start with a MACH/API-first platform (especially commercetools or Salesforce) rather than a traditional storefront-centric platform, because the same backend capabilities can serve every touchpoint. Developer deloittedigital.com

A useful next decision point is whether your in-store screens are primarily digital signage/content experiences or transactional surfaces (browse → cart → checkout)—that changes the ideal platform choice significantly.

Yes. For your specific use case—one commerce backend powering both web experiences and in-store screens/POS—I’d put commercetools at the top of the shortlist.

Best fits

• commercetools.com — strongest enterprise fit. Its APIs cover products, carts, customers, orders, inventory, pricing, etc., and its Store/Channel model is explicitly designed to represent both online stores and physical retail locations. commercetools Documentation commercetools Documentation
• commercetools.com is particularly relevant: it extends the same platform into physical stores with mobile POS, assisted selling, omnichannel fulfillment, returns, and shared commerce data. commercetools commercetools Documentation
• saleor.io — strong open-source/API-native alternative. Saleor explicitly supports web, mobile, retail, and other channels through its headless architecture. Saleor Commerce
• medusajs.com — strong developer-centric option. Its REST APIs can power multiple storefronts, while sales channels let you model different commerce channels. Medusa Docs Medusa Docs
• shopify.com — good if you want SaaS simplicity. Its Storefront API supports custom web/app experiences, and Shopify supports headless experiences beyond conventional websites. Shopify Shopify Help Center

For your architecture

I'd think about it as:

Commerce platform → unified APIs → experience layer → web / in-store screens / mobile / POS

The important distinction is that you don't merely want a platform with a "Storefront API." You want the same underlying product, pricing, inventory, customer, cart, order, and fulfillment model available to every touchpoint.

That's where commercetools stands out. Its own documentation describes an API orchestration approach where multiple backend capabilities can be exposed through a unified API to different customer-facing channels. commercetools

If in-store screens mean digital signage/product discovery only, Medusa or Saleor could be very attractive. If they mean actual associate selling + POS + checkout + returns + inventory, I'd strongly favor commercetools, especially with InStore.

If you tell me your expected scale, existing POS/ERP, and whether the in-store screens need checkout, I can narrow this to a 2–3 platform architecture comparison.

For an omnichannel experience spanning web storefronts + in-store digital screens/kiosks + potentially mobile, POS, and marketplaces, you’ll want a headless commerce platform with a single commerce API layer for products, pricing, inventory, customers, carts, checkout, orders, and promotions—not just a headless CMS.

Strong candidates:

For your specific use case (web + in-store screens), I’d evaluate these capabilities:

1. Shared commerce APIs

• Product catalog
• Real-time inventory by location
• Pricing/promotions
• Customer profiles
• Cart and checkout
• Order history and returns
• Store-aware experiences

• “Find this item in this store”
• Endless aisle (order online from store)
• Local inventory visibility
• Store-specific pricing/promotions
• Composable front ends

• Web app
• In-store kiosk/tablet
• Digital signage
• Associate devices
• Mobile app
• Event-driven architecture

• Inventory changes propagate instantly
• Customer actions sync across channels
• Orders trigger fulfillment workflows

My shortlist by scenario

• Global retailer with hundreds of stores: commercetools or Salesforce
• Retailer already using Microsoft ERP/POS: Microsoft Dynamics 365 Commerce
• Brand moving quickly with fewer legacy constraints: Shopify Plus headless
• Highly differentiated in-store experiences: commercetools is often the most flexible

A key architecture question: are the in-store screens meant to sell (browse → cart → checkout), or are they primarily digital merchandising/signage? That changes whether you need a full commerce API stack or just a content/personalization layer.

Yes. If your goal is one commerce backend powering both web and in-store screens, I’d shortlist these:

My pick

For a true omnichannel/headless architecture, I'd lean toward commercetools or Saleor.

• commercetools is particularly strong if you're an enterprise and want commerce capabilities exposed as reusable APIs across many touchpoints. Its APIs cover the underlying commerce resources rather than tying you to a particular storefront. commercetools Documentation Commercetools
• Saleor is compelling if you want a very clean GraphQL-first, API-only architecture. Its multi-channel model lets a single backend serve multiple channels, with channel-specific pricing, inventory, products, etc. Saleor Commerce Saleor Documentation
• Medusa is attractive if your engineering team wants to own more of the architecture. Its docs explicitly describe using one backend for multiple storefronts and exposing commerce functionality through APIs. Medusa Documentation
• Shopify deserves serious consideration if "in-store" means an actual retail/POS experience rather than simply a custom kiosk. Its Storefront API can power custom experiences on essentially any platform, while its Admin API manages commerce across online, POS, and other channels. Shopify Shopify

Architecture-wise, I'd model it as:

Commerce platform → unified catalog / pricing / inventory / customer / cart / order APIs → web frontend + in-store screen + mobile + POS

The key question isn't just "does it have APIs?"—it's whether inventory, pricing, carts, customers, promotions, and orders have consistent semantics across channels.

If you tell me whether you're enterprise vs. mid-market and whether the in-store screens are kiosks, assisted-selling tablets, or full POS, I can narrow this to the best 2–3 platforms.

For your use case, I’d shortlist commercetools first, with Saleor as the strongest alternative.

My pick: commercetools

If the requirement is genuinely one commerce backend powering both your website and physical-store screens/POS, commercetools is particularly compelling. Its platform is explicitly designed around APIs powering different touchpoints, including websites, apps and in-store experiences. commercetools commercetools Documentation

More importantly, its InStore product connects ecommerce, store operations, inventory, customer and order data on a single commerce platform. It supports use cases such as clienteling, endless aisle, mobile checkout, omnichannel returns and BOPIS. commercetools

It also has store-scoped APIs, so physical locations can be represented as first-class commerce contexts rather than having a separate backend for stores. commercetools Documentation

When I'd choose Saleor instead

If your team strongly prefers GraphQL everywhere, wants an open-source/composable architecture, and is comfortable building more of the in-store layer yourself, Saleor is attractive. It is API-only and GraphQL-native, with native multi-channel support and APIs intended to power different experiences. Saleor Commerce Saleor Commerce

Its documentation also specifically covers click-and-collect, multi-region experiences and channels. Saleor Documentation

Bottom line: for a retailer building web + in-store screens + potentially POS/clienteling/endless aisle, I'd start the evaluation with commercetools. For a highly custom, engineering-centric stack where API purity and control matter most, I'd put Saleor alongside it.

commercetools.com · commercetools.com · saleor.io

Yes. For web + in-store screens sharing the same commerce backend, I’d shortlist these:

My pick

commercetools is probably the strongest fit if you're building a serious omnichannel retail architecture. Its current platform explicitly combines headless commerce, unified commerce, and in-store capabilities, with APIs serving different touchpoints from a common foundation. commercetools commercetools

For example, you could have:

Commerce backend → APIs → Web storefront
↳ In-store kiosk
↳ Associate tablet
↳ Mobile app

with product, pricing, inventory, customer, cart, and order state shared rather than implementing separate commerce logic per channel.

commercetools.com

Saleor is the alternative I'd look at most closely if you want a more developer-centric/open-source approach. It is GraphQL-native and API-only, supports native multi-channel operations, and explicitly positions itself for web, mobile, retail, and other channels. Saleor Commerce Saleor Commerce

saleor.io

Medusa is compelling if you want maximum control over the architecture. Its Sales Channel Module supports online/offline channels, while its Store APIs let multiple storefronts consume the same commerce system. docs.medusajs.com docs.medusajs.com

medusajs.com

If you tell me your scale (e.g. 50 vs. 5,000 stores), whether you need POS/OMS, and your frontend stack, I can narrow this to the best 2–3 and compare their API/data models.

Yes. If your goal is one commerce backend powering both web and in-store screens through the same APIs, I’d shortlist these:

My pick: commercetools

For the architecture you're describing, commercetools is probably the strongest fit.

The important distinction is that you don't want:

Web storefront → commerce API
In-store screen → separate POS API
→ synchronize them afterward

You want:

Web UI ─┐
In-store UI ─┼→ shared commerce APIs → catalog / pricing / inventory / customer / cart / order
Mobile UI ─┘

commercetools' model is particularly well suited to that because Stores can represent physical retail locations or regions, while distribution/supply channels let you control assortment, prices and inventory. commercetools Documentation commercetools Documentation

For example, an in-store screen could use the same underlying product/catalog APIs as your website, but be scoped to:

Store = Boston Flagship
Inventory = Boston
Price = Retail
Assortment = Flagship assortment

while the web experience could use:

Store = Online US
Inventory = E-commerce warehouses
Price = Online

That gives you one commerce model with channel-specific context, rather than maintaining separate commerce implementations.

BigCommerce is the better alternative if you prioritize faster implementation and a more conventional SaaS commerce platform. Its headless APIs explicitly support storefronts such as websites, native apps and kiosks, and its channel model is quite mature. BigCommerce BigCommerce

If you tell me whether the in-store screens are POS checkout terminals, associate tablets, customer-facing kiosks, or digital signage, I can narrow this to the best 2–3 architectures and show what the API layer would look like.

Yes. For one commerce backend serving both web and in-store screens, I’d put commercetools at the top of the shortlist.

My recommendation: commercetools

The important distinction is that commercetools isn't merely saying "you can call our APIs from multiple channels." Its current platform explicitly combines B2C, B2B, InStore and other channels on one commerce foundation. Its Store model can represent physical retail locations, with store-scoped APIs for carts, orders, products, etc. commercetools.com

It also has commercetools InStore, which provides POS, clienteling, checkout, inventory/fulfillment, returns, and physical payment capabilities. That makes it particularly relevant if your "in-store screens" eventually become interactive kiosks or assisted-selling terminals rather than just digital signage. docs.commercetools.com

A useful architecture would be:

Web storefront
↕
Shared commerce APIs / orchestration
↕
Products · pricing · customer · inventory · cart · order
↕
In-store kiosk / associate screen / POS

That gives you the possibility of the same cart/customer/inventory context following someone between web and store rather than maintaining separate commerce implementations.

commercetools

When I'd choose the others

• Saleor if your team strongly prefers GraphQL and wants maximum frontend/control flexibility. Saleor describes its platform as GraphQL-native with a single backend supporting multiple channels/storefronts. saleor.io
• Medusa if you're comfortable owning more of the architecture. Its REST Store APIs and Sales Channel Module are explicitly designed to support multiple storefronts/channels. docs.medusajs.com
• Swell if you want a simpler API-first platform; notably, it says its features are available through a unified backend API that also powers its dashboard and checkout. www.swell.is

If you're building enterprise retail with web + kiosks + POS + shared inventory/customer/order state, I'd evaluate commercetools first. If the screens are primarily content/digital-signage displays rather than transactional, the choice becomes much more about your CMS/content architecture than the commerce platform itself.

Yes. For a web + in-store-screen architecture, I’d shortlist commercetools, Saleor, and Medusa—with commercetools probably the strongest enterprise fit.

My recommendation: commercetools

commercetools is particularly aligned with what you're describing. Its headless architecture is explicitly designed to let web, mobile, kiosks and other touchpoints operate against the same commerce foundation. Its current platform also has an InStore capability intended to unify online and physical retail experiences. commercetools commercetools

It also has explicit Store-scoped APIs, so you can model individual physical locations or other shopping contexts and scope carts, orders, products, etc. to them. Commercetools Documentation Commercetools Documentation

Saleor is a very strong alternative

Saleor is especially attractive if your team is engineering-heavy. It's GraphQL-only/API-only, supports native multi-channel configuration, and lets different frontends consume the same commerce API. Its channels can have their own pricing, currencies, inventory, products and related configuration. GitHub Saleor Commerce

That makes a setup like:

Web storefront → Saleor API ← In-store touchscreen
Mobile app → Saleor API
POS/services → Saleor API

quite natural.

One architectural distinction I'd make

Don't just ask whether the platform has "unified APIs." For your use case, I'd evaluate whether the same underlying customer, cart, inventory, pricing, promotion, and order model can be accessed consistently from both experiences.

For example, your in-store screen should ideally be able to:

• identify the customer
• show location-specific inventory
• access the same product/catalog data as web
• create or resume the same type of cart
• apply the same promotions/pricing rules
• support pickup/ship-to-home
• create an order that appears in the same customer/order history

Saleor explicitly documents click-and-collect and multi-channel capabilities, while commercetools has dedicated in-store APIs/capabilities, so both are worth serious evaluation. Saleor Documentation commercetools

If you're an enterprise with physical retail: I'd start with commercetools.

If you're building a highly custom experience and want GraphQL/open-source control: I'd start with Saleor.

If you want a more developer-controlled modular stack: look at Medusa; its documentation specifically describes using multiple storefronts against one commerce backend and its Sales Channel Module for omnichannel scenarios. Medusa Docs Medusa Docs

If you tell me your number of stores, POS system, ERP, and whether the in-store screens need checkout or are primarily assisted-selling/kiosk screens, I can narrow this to a concrete architecture and platform choice.

Web storefront → Saleor API ← In-store touchscreen
Mobile app → Saleor API
POS/services → Saleor API

quite natural.

One architectural distinction I'd make

Don't just ask whether the platform has "unified APIs." For your use case, I'd evaluate whether the same underlying customer, cart, inventory, pricing, promotion, and order model can be accessed consistently from both experiences.

For example, your in-store screen should ideally be able to:

Yes. If “unified APIs” means one commerce backend powering both your headless web experience and in-store screens/POS, I’d put commercetools at the top of the shortlist.

Why I'd favor commercetools

Its architecture is particularly aligned with what you're describing: the same API-first commerce foundation can serve websites, mobile, kiosks, and physical retail. Its current InStore offering explicitly connects ecommerce, store operations, inventory, customer and transaction data on one platform. commercetools.com

It also has store-scoped APIs, so a physical store can operate against the same underlying carts, orders, products and inventory model rather than maintaining a separate commerce stack. docs.commercetools.com

Shopify is a very good alternative if speed and operational simplicity matter more than architectural flexibility. Its Storefront API supports custom web experiences, while its Admin API manages availability across online stores and POS; Shopify also provides native omnichannel capabilities such as buy-online-pickup-in-store and buy-in-store/ship-to-home. www.shopify.com

Salesforce makes sense if CRM/customer identity, personalization, and Salesforce integration are central. Its Commerce APIs expose shopper and admin functionality, while Salesforce also provides APIs for Omnichannel Inventory. developer.salesforce.com

My recommendation:

• Complex enterprise retail + custom in-store screens + unified inventory/order/customer model → commercetools
• Want the fastest route to web + POS → Shopify
• Deep Salesforce ecosystem / CRM-led personalization → Salesforce

If you tell me whether the in-store screens are POS terminals, associate/clienteling screens, digital signage, or customer self-service kiosks, I can narrow this to the best 2–3 architectures.

Yes. For your use case—one commerce backend powering both web and in-store screens—I’d shortlist these:

My pick: commercetools

For a genuinely unified web + physical experience, commercetools is probably the strongest fit. Its current platform explicitly supports B2C, B2B and InStore capabilities, with commerce functionality exposed through APIs. commercetools.com

More importantly, its model lets you define Stores and Channels and associate them with physical retail locations or online stores, while sharing product availability, inventory and pricing strategies. docs.commercetools.com

That means you could have something like:

Commerce backend
→ Catalog
→ Pricing/promotions
→ Customer
→ Cart
→ Inventory
→ Orders
→ Checkout

…and expose the same underlying commerce capabilities to:

• www.brand.com
• in-store touchscreen
• associate tablet
• kiosk
• mobile app
• potentially future AI/voice experiences

That's much closer to "one commerce brain, many experiences" than treating the website and store screens as separate storefronts.

Saleor is the other one I'd seriously evaluate

Saleor is particularly attractive if your engineering team wants maximum frontend freedom. It's GraphQL-native, supports multiple channels from a single backend, and explicitly supports experiences across web, retail and other channels. saleor.io

I'd choose Saleor over commercetools if open-source/control and a GraphQL-first architecture are major priorities.

BigCommerce

BigCommerce can absolutely power headless web and custom experiences: its GraphQL Storefront API handles catalog, customer, cart and checkout, and its headless architecture supports essentially any frontend, including kiosks/apps. docs.bigcommerce.com

Its channel model also lets you configure separate storefront experiences while maintaining the commerce backend. docs.bigcommerce.com

Bottom line: if "unified APIs across web + physical retail" is a core architectural requirement rather than just "we need a headless website," I'd start with commercetools, then compare Saleor and BigCommerce against it.

If you tell me your B2C/B2B mix, number of stores, POS requirements, and whether inventory needs to be real-time across locations, I can narrow this to a 2–3 platform architecture comparison.

For an omnichannel experience where web storefronts, mobile apps, kiosks, clienteling apps, and in-store screens all need to consume the same commerce capabilities, you’ll want a platform with:

• API-first/headless architecture
• Unified catalog, pricing, inventory, customer, cart, checkout, and order APIs
• Real-time inventory visibility across stores and online
• Support for custom front ends (React, Next.js, native apps, in-store UIs)
• Strong integration with OMS/POS/ERP systems

Platforms commonly evaluated for this use case:

A few architecture patterns:

1. Composable retail (most flexible)

Web / Mobile / Store Screens / Kiosks
              |
        Experience Layer
              |
      Headless Commerce APIs
              |
 Catalog | Pricing | Cart | Checkout | Orders
              |
 ERP | OMS | POS | Inventory

Best matches: commercetools, Salesforce headless, Adobe Commerce.

2. Store-as-a-channel approach
Your in-store screens behave like another digital storefront:

• same product APIs
• same customer identity
• same promotions
• same inventory service
• same checkout/order flows

For example, Salesforce positions its headless APIs as a way to connect touchpoints including in-store kiosks and other channels. www.salesforce.com commercetools similarly emphasizes API-first commerce with modular services and in-store capabilities. commercetools.com

My shortlist for a true unified web + physical retail experience:

1. commercetools — if your team wants maximum frontend freedom and a composable architecture.
2. Salesforce Commerce Cloud — if customer profiles, CRM, loyalty, service, and marketing are central.
3. SAP Commerce Cloud — if ERP/store operations are deeply SAP-based.
4. Adobe Commerce — if merchandising flexibility and custom commerce logic are priorities.

The biggest decision point is usually not the storefront APIs — most major platforms have them — but whether you want the commerce platform to also own customer identity, promotions, inventory orchestration, and order management, or whether those remain separate services.

For a web + in-store screen experience, you’ll want a headless/composable commerce platform with a single commerce API layer so every channel consumes the same products, pricing, inventory, customer, cart, promotions, and order services.

Strong candidates:

For your specific use case (web storefront + in-store digital screens), I’d evaluate them against these capabilities:

1. Shared product and pricing APIs
   • Same SKU data, merchandising rules, promotions, and availability everywhere.

2. Real-time inventory
   • Store screens should know store stock, warehouse stock, and fulfillment options.

3. Unified customer identity
   • A shopper browsing online should be recognized in-store if you support loyalty/clienteling.

4. Order orchestration
   • Buy online/pick up in store, ship-from-store, return anywhere.

5. Content separation
   • Pair commerce APIs with a headless CMS so marketing teams can manage screen content without deployments.

A typical architecture would look like:

Web React/Next.js
        |
In-store screens / kiosks
        |
Mobile app
        |
        ↓
Commerce API layer
        |
Products | Pricing | Cart | Checkout | Inventory | Orders
        |
ERP / OMS / CRM / Loyalty

My shortlist by scenario:

• Large retailer with stores, POS, loyalty, and complex operations: Salesforce Commerce Cloud or commercetools.
• Mid-market brand wanting speed: Shopify headless.
• Highly custom retail ecosystem: commercetools or Elastic Path.
• Content-heavy store displays + commerce: Adobe Commerce + headless CMS.

The key architectural decision is less “which storefront framework?” and more which platform can make commerce capabilities channel-agnostic so your web and physical screens are just different clients of the same APIs. business.adobe.comwww.salesforce.com

Yes. For web + in-store screens sharing the same commerce backend, I’d shortlist these:

My pick: commercetools

commercetools is particularly aligned with what you're describing. It explicitly supports a single commerce backend across channels, with centralized product, inventory, customer and order data. Its API orchestration capabilities can also expose multiple backend systems through a unified API to different customer-facing channels. commercetools.com

That means you could have:

Commerce backend
→ product/catalog
→ pricing/promotions
→ inventory
→ carts/checkout
→ customers
→ orders

and then expose those capabilities to:

Web storefront | In-store touchscreen | Mobile app | Associate tablet | Kiosk

without creating separate commerce logic for each experience.

commercetools API-first commerce

Strong alternative: Saleor

Saleor is especially compelling if your team wants a GraphQL-native, API-only architecture. Saleor describes itself as supporting a single API layer for all selling channels, with native channel controls for pricing, currencies, stock and products. github.com

So if your architecture is something like:

Next.js web → GraphQL → Saleor
React in-store UI → GraphQL → Saleor

that's a very clean model.

Saleor headless commerce

Bottom line: if you're an enterprise retailer and need sophisticated omnichannel orchestration, I'd start with commercetools. If you're a technically strong product team prioritizing API simplicity, GraphQL and maximum frontend control, I'd seriously evaluate Saleor.

If you tell me your stack (e.g. React/Next.js), ERP/PIM, POS system, and whether the in-store screens need checkout or are browse-only, I can narrow this to the best 2–3 architectures.

Yes. For an omnichannel setup where the same commerce backend needs to power your website, in-store screens/kiosks, mobile, and potentially POS, I’d shortlist these:

My pick: commercetools

For your specific requirement, commercetools is probably the strongest fit. Its architecture is explicitly designed around a single commerce backend serving multiple channels. It provides REST and GraphQL APIs for real-time commerce operations, while its orchestration layer can expose backend data and processes to different channels through a unified API. commercetools.com

That maps nicely to something like:

Commerce backend → API/orchestration layer → Web / In-store display / Kiosk / Mobile / POS

So an in-store screen could use the same underlying product, pricing, inventory, customer, cart, and order capabilities as the web experience rather than maintaining a separate commerce implementation.

Saleor is a particularly interesting alternative

If your team is more engineering-heavy and wants maximum frontend freedom, Saleor is worth serious consideration. It's headless/API-only and GraphQL-native, with native multichannel support for things like pricing, currency, stock, and product availability. github.com

I'd lean Saleor if you want an open-source, developer-centric platform and don't need as much enterprise commerce infrastructure out of the box.

Medusa

Medusa is another good option, especially if you want to own more of the architecture. Its Sales Channel Module supports multiple channels, while its REST Store APIs can power multiple storefronts from the same server. docs.medusajs.com

Bottom line:

• Enterprise retail + web/in-store/POS orchestration → commercetools
• Highly custom, API/GraphQL-first experience → Saleor
• Open-source/modular + maximum backend control → Medusa

If you tell me whether you need POS, real-time store inventory, customer identity, and shared carts between web and in-store, I can narrow this to the best 1–2 architectures.

Yes. For web + in-store screens with a shared commerce backend, I’d shortlist these:

My pick for your use case

commercetools is probably the strongest architectural fit if “unified APIs” is the central requirement. Its model explicitly treats physical stores and online locations as Stores, with channels, inventory, carts, orders, pricing, and product availability managed through the same commerce platform. It also now has InStore, an API-first POS designed to unify online and physical retail. docs.commercetools.com

commercetools InStore

Shopify is the stronger choice if you want to get to market faster. Its Storefront API can power custom web experiences, while Shopify's unified commerce model connects online storefronts and POS to common products, customers, orders, inventory, and other data. shopify.dev

Shopify Storefront API documentation

For your specific architecture, I'd think about it as:

Web UI ─┐
In-store screen ─┤ → shared commerce APIs → catalog / pricing / inventory / cart / customer / order
Mobile ─────────┘

If the in-store screen needs real-time inventory, customer recognition, endless aisle, BOPIS, cart handoff between screen and phone, and associate-assisted checkout, I'd lean commercetools. If it's primarily a branded kiosk/display with standard checkout, Shopify becomes very compelling.

Yes. For web + in-store screens/POS sharing the same commerce data and APIs, I’d shortlist these:

My pick for your use case

commercetools is probably the strongest fit if your goal is genuinely one commerce backend serving multiple bespoke experiences. Its API orchestration layer is specifically designed to make backend data, processes and actions available across channels through APIs, while its InStore product provides APIs for carts, payments, returns and physical-store workflows. commercetools.com

If you want a more turnkey retail solution, Salesforce is compelling: its current stack explicitly connects B2C Commerce, POS and Order Management, with shared customer, order and inventory information across online and physical channels. trailhead.salesforce.com

If the in-store screens are more like interactive kiosks/endless-aisle displays than full POS terminals, I'd lean even more toward commercetools or Medusa. Medusa exposes commerce through REST APIs and is explicitly designed to support multiple storefronts from one server. docs.medusajs.com

Architecture-wise, I'd look for:
Web storefront ─┐
In-store UI ─────┼→ shared commerce APIs → products / pricing / cart / inventory / orders
Kiosk ───────────┘

That avoids building separate commerce logic for the web and store applications.

commercetools · Salesforce Commerce · Shopify headless commerce · Medusa 

Yes. For your specific requirement—one commerce backend serving both web and in-store screens through the same API layer—I’d shortlist these:

My top pick: commercetools

commercetools is particularly well aligned with what you're describing. Its architecture explicitly models Stores, Channels, inventory, pricing, carts and orders, and a Store can represent either a physical retail location or an online experience. docs.commercetools.com

More importantly, commercetools describes an API-orchestration layer that can make backend data and processes available to different channels through a unified API. commercetools.com

That means you could have something like:

                 Commerce Backend
                       │
              commercetools APIs
                       │
        ┌──────────────┼──────────────┐
        │              │              │
     Web Store    In-Store Kiosk   Associate Screen
        │              │              │
     Next.js        React/etc.     React/etc.

All three experiences can consume the same underlying catalog, customer, pricing, inventory, cart and order concepts, while applying different channel/store context.

Saleor is a strong alternative

Saleor is arguably even cleaner if your engineering team wants GraphQL everywhere. Saleor is API-only/headless, GraphQL-native, and has native multi-channel support with channel-specific pricing, currencies, stock and products. github.comshopify.dev

I'd lean Saleor if your team wants maximum control over the frontend and a relatively pure composable architecture.

Shopify

Shopify also supports headless experiences through its Storefront API, which is designed to expose commerce primitives to websites, apps and other custom experiences. shopify.dev Its big advantage is the mature retail/POS ecosystem, but you may encounter more platform-specific constraints than with commercetools or Saleor.

Bottom line: If the core architectural requirement is "web and physical screens are just different clients of the same commerce APIs," I'd evaluate commercetools first, Saleor second, Shopify third. For a large enterprise, commercetools is probably the strongest fit; for an engineering-led, highly customized experience, Saleor is very compelling. docs.commercetools.com

If you tell me whether your in-store screens are kiosks, POS terminals, digital signage, or associate tablets, I can narrow this down considerably.

Yes. For your specific use case—one commerce backend powering both web and in-store screens/kiosks—I’d shortlist these:

My recommendation

If by "unified APIs" you mean the web frontend and an in-store touchscreen should call essentially the same commerce services, I'd put commercetools first.

Its architecture is particularly aligned with this: commercetools describes an API orchestration layer that can unify multiple backend APIs and make their data, processes, and actions available to any channel through one API. commercetools.com

If you're a large retailer already invested in Salesforce, Salesforce Commerce Cloud becomes very compelling because Salesforce explicitly supports headless experiences extending to in-store kiosks, while its Omnichannel Inventory APIs address the physical/digital inventory problem. commercetools.comwww.salesforce.comwww.bigcommerce.comwww.salesforce.comwww.bigcommerce.com

BigCommerce is the pragmatic choice if you want strong headless APIs without taking on as much composable-platform complexity. Its multi-location inventory APIs are particularly relevant for tying physical stores to online experiences. www.bigcommerce.comwww.bigcommerce.com

For your architecture, I'd specifically evaluate whether the platform can expose the same primitives for catalog → pricing → customer → cart → checkout → inventory → order → fulfillment to both channels. That's more important than simply having a "headless" label.

If you tell me your POS, ERP/inventory system, and whether the in-store screens are kiosks or associate-facing, I can narrow this to the best 1–2 platforms and sketch the API architecture.

Yes. For your use case—one commerce backend powering both web and in-store screens through APIs—I’d shortlist these:

My recommendation

If “unified APIs across web + in-store screens” is the architectural priority, I'd put commercetools first.

Its model is particularly well suited to having something like:

Commerce backend → unified API/orchestration → web storefront + store kiosk + associate tablet + digital signage

That lets the different experiences share product, pricing, inventory, customer and order data without forcing every frontend to implement separate commerce integrations. commercetools explicitly describes using an orchestration layer to make multiple backend APIs and processes available through a unified API. commercetools.com

Salesforce would be my first choice if you already have Salesforce CRM/OMS/Marketing infrastructure and want the commerce experience tightly integrated with that ecosystem. Its headless APIs explicitly target touchpoints such as in-store kiosks as well as digital channels. www.salesforce.com

Shopify is attractive if you prioritize speed and operational simplicity. Its Storefront API can serve custom experiences across web and other platforms, but I'd evaluate the in-store/POS requirements carefully if your screens need sophisticated store-specific inventory, fulfillment, customer identity, or transaction workflows. shopify.dev

If you tell me your company size, B2C vs. B2B, existing stack (Salesforce/Adobe/SAP/etc.), and what the in-store screens actually do (browse-only, kiosk checkout, associate-assisted selling, endless aisle, etc.), I can narrow this to 2–3 platforms and map the API architecture.

Yes. For your use case—one commerce backend serving both web and in-store screens—I’d shortlist these:

My recommendation: commercetools

It is particularly aligned with what you're describing. commercetools explicitly supports a single commerce backend as the source of truth for product, customer, inventory, etc., with APIs/orchestration exposing that data to different channels. Its platform models Stores and Channels, including physical locations, and supports store-scoped APIs. commercetools.com

It also now has InStore, designed specifically to unify online and physical-store operations on the same commerce platform. commercetools.com

So architecturally you could have:

Commerce backend
→ products / pricing / inventory / customers / carts / orders
→ common API/orchestration layer
→ Web storefront
→ In-store kiosk
→ Associate-facing screen
→ Digital signage
→ Mobile app

That's preferable to creating separate "web commerce" and "store commerce" APIs and trying to synchronize them afterward.

Saleor is the interesting alternative

If you're heavily engineering-led, Saleor is compelling: its backend is API-only and GraphQL-native, with native multi-channel support for pricing, currency, stock, and products. github.com

Shopify

Shopify's Storefront API can power custom experiences across web, native apps, games, social and other platforms, so it's certainly capable of a headless architecture. shopify.dev

But if "one API/data model spanning web + physical retail" is the architectural requirement, I'd evaluate commercetools before Shopify.

Bottom line:

• Enterprise omnichannel / complex stores: commercetools
• Maximum API/developer control: Saleor
• Fastest path + huge ecosystem: Shopify

If you tell me whether the in-store screens are kiosks, POS/associate screens, or digital signage, I can narrow this down considerably.