ChatGPT answers, unedited

If CMS-first is the priority and commerce is primarily an API/service layer, I’d pick Sanity + Shopify for most teams.

My recommendation: Sanity + Shopify

The architecture would be:

Next.js / frontend
→ Sanity = source of truth for product-page content, merchandising/editorial structure, SEO, landing pages
→ Shopify Storefront API = price, inventory, variants, cart, checkout, orders
→ Sanity Connect = synchronizes Shopify products/variants/collections into Sanity

That is unusually well aligned with a CMS-first model. Sanity's current Shopify integration can sync products, variants, and collections into the Content Lake, while letting editors enrich those products with structured content in Sanity Studio. www.sanity.io

So a product page can essentially be:

Product
├── Commerce identity
│   ├── Shopify product ID
│   ├── variants
│   ├── price
│   ├── inventory
│   └── purchase/checkout data
│
├── Core product content
│   ├── title
│   ├── description
│   ├── media
│   └── specifications
│
└── Editorial experience
    ├── hero
    ├── benefits
    ├── comparison modules
    ├── buying guide
    ├── reviews
    ├── FAQs
    ├── related stories
    └── SEO

The important distinction is that Shopify remains the transactional system; Sanity becomes the experience/content system. Sanity explicitly positions this as the content layer rather than a replacement for the commerce platform. www.sanity.io

Why I'd choose it over the alternatives

Contentful is the strongest alternative. It has a mature Shopify integration where editors can reference Shopify products/collections, and its APIs can resolve those commerce references through GraphQL. www.contentful.com

But for product pages as structured content, I lean Sanity because its document/reference model makes it particularly natural to compose a product from commerce data plus arbitrary editorial modules.

One architectural decision I'd make early

Don't make the CMS your transactional product database.

I'd model it as:

Shopify owns

• SKU
• variant IDs
• price
• inventory
• availability
• selling plans
• cart
• checkout

Sanity owns

• product storytelling
• merchandising content
• page composition
• SEO
• rich media
• buying guides
• FAQs
• comparisons
• campaigns
• cross-product editorial relationships

Then the frontend joins the two APIs.

That's essentially the architecture Sanity is currently demonstrating with Shopify + Hydrogen: Shopify products are fetched alongside Sanity's structured content, with Sanity used to embellish the raw commerce data. www.sanity.io

If you're starting greenfield, my stack would be:
Next.js + Sanity + Shopify Storefront API + Sanity Connect, with a component-based product-page schema.

Sanity + Shopify documentation

If you tell me whether you're B2C, B2B, or marketplace, and roughly how many SKUs/locales you expect, I can narrow this down between Sanity, Contentful, Payload, and a commerce-native CMS.

If CMS-first is the priority—meaning the CMS owns the product-page experience and commerce is primarily an API behind it—I’d pick Sanity.

My recommendation: Sanity + commerce API

Sanity is particularly well suited because you can model the product page as structured content rather than treating the commerce platform's product template as the source of truth. Sanity explicitly supports products, variants, attributes, editorial content, and references as structured data, while connecting to commerce systems through APIs. Sanity.io Sanity.io

A good architecture would be:

Next.js → Sanity → commerce API

with:

• Sanity — product storytelling, SEO, merchandising content, buying guides, editorial modules, localization, page composition
• Commerce API — price, inventory, variants, cart, checkout, promotions, orders
• Next.js — presentation and performance
• CDN/cache — fast delivery of mostly-static product content, with commerce data fetched dynamically

If you're already on Shopify, Sanity has a current Shopify integration that synchronizes Sanity and Shopify and supports a headless Next.js/Hydrogen setup. Sanity.io

How I'd rank the CMS options

Storyblok is particularly compelling if non-technical marketers need to visually assemble PDPs. Sanity is stronger if developers want the content model to be a genuine data model that can evolve with the business. Current comparisons generally put Sanity ahead on developer flexibility and Storyblok ahead on visual editing. CodeDrips Naturaily

One architectural distinction I'd make

Don't make the CMS's Product document a duplicate of the commerce system's entire product object.

Instead, I'd have something conceptually like:

Sanity
├── ProductContent
│   ├── commerceProductId
│   ├── title / storytelling
│   ├── description
│   ├── media
│   ├── SEO
│   ├── buying guides
│   ├── feature modules
│   └── merchandising relationships
│
└── ProductPage
    ├── hero
    ├── content modules
    ├── reviews module
    ├── recommendations
    └── editorial content

Commerce API
├── product/variant identity
├── price
├── availability
├── inventory
├── discounts
├── cart
└── checkout

That separation keeps the CMS genuinely CMS-first instead of turning it into a shadow commerce database.

Interestingly, Sanity even has a Commerce Layer integration that models products/variants in Sanity while leaving transactional commerce to Commerce Layer—the exact separation you're describing. Sanity.io

Bottom line: I'd choose Sanity unless your overriding requirement is visual page editing for marketers, in which case I'd choose Storyblok. If you tell me which commerce API you're considering—Shopify, commercetools, Medusa, Saleor, Commerce Layer, Vendure, etc.—I can recommend the exact CMS + commerce architecture.

If your priority is CMS-first product pages, I’d choose Sanity as the CMS and keep commerce as a separate API-driven system.

My default architecture

Sanity + Shopify / commercetools / another commerce engine + Next.js

• Sanity owns the experience and product-enrichment layer: descriptions, storytelling, SEO, buying guides, merchandising content, images, videos, FAQs, badges, related content, etc.
• Commerce API owns transactional truth: price, inventory, variants/SKUs, carts, checkout, promotions, tax, fulfillment.
• Next.js renders the product page and composes both sources.
• Product records in Sanity reference the commerce product/variant IDs rather than becoming the transactional source of truth.

This is particularly well aligned with Sanity's current ecommerce model: it supports structured product/variant schemas, references products throughout editorial content, visual editing, and integrations with commerce backends including Shopify. Sanity.io Shopify

Why I'd pick Sanity

For a genuinely CMS-first approach, Sanity has an unusually good fit because you can model a product page as content rather than treating it as a commerce template:

Product Page
├── Product reference → Commerce API
├── Hero
├── Story
├── Product highlights
├── Media gallery
├── Buying guide
├── Size/fit information
├── FAQs
├── Reviews reference
├── Related products
├── SEO
└── Merchandising components

Then your frontend resolves the commerce data at request/render time:

Sanity
  │
  │ editorial/product enrichment
  ▼
Next.js ────────────────► Commerce API
  │                         │
  │                         ├─ price
  │                         ├─ inventory
  │                         ├─ variants
  │                         └─ availability
  ▼
Product Page

That separation is important: don't put price/inventory/checkout state into the CMS just because you're making the CMS the center of the experience.

How I'd rank the options

Contentful is especially compelling if governance and enterprise content operations are the dominant concern; Shopify's own current guidance similarly positions Contentful around structured/localized/preview-heavy editorial operations and Sanity around custom authoring and flexible schemas. Shopify

One architectural decision I'd make early

I would not make the CMS the canonical commerce catalog unless you have a specific reason to.

Instead:

Commerce system = product identity + transactional truth
CMS = product experience + editorial truth

For example:

commerce_product_id: "gid://shopify/Product/123"

in Sanity, with all the rich page content around that reference.

That gives you freedom to change the commerce backend later without rebuilding your content model. Sanity also explicitly supports the pattern of connecting commerce backends while keeping structured product content in the CMS. Sanity.io Sanity.io

So if you're starting from scratch, my pick would be: Sanity + Next.js + a commerce API. If you tell me whether you're considering Shopify, commercetools, BigCommerce, Medusa, or something custom, I can recommend the exact stack and data model I'd use.

If your priority is CMS-first product pages, I’d choose Sanity + a separate commerce engine rather than making the commerce platform your page/content system.

My pick: Sanity

Sanity is particularly well suited because you can make the CMS the place where merchandisers build the entire product-page experience—storytelling, rich copy, media, buying guides, specs, FAQs, related content, merchandising modules—while the commerce API remains authoritative for price, inventory, variants, cart, checkout, and orders.

Sanity explicitly supports commerce integrations, including Shopify synchronization, and its APIs are designed to let you query the CMS from essentially any frontend. www.sanity.io

A good architecture would be:

                    ┌─────────────────┐
                    │      Sanity     │
                    │                 │
                    │ Product content │
                    │ Page composition│
                    │ Editorial       │
                    │ Media           │
                    │ SEO             │
                    └────────┬────────┘
                             │
                    CMS API / GROQ
                             │
                             ▼
┌──────────────┐      ┌───────────────┐      ┌──────────────┐
│ Commerce API │─────▶│   Next.js /   │◀─────│ Search / PIM │
│              │      │   storefront  │      │              │
│ price        │      │               │      │              │
│ inventory    │      │ Product page  │      │              │
│ variants     │      │ composition   │      │              │
│ cart         │      └───────┬───────┘      └──────────────┘
│ checkout     │              │
└──────────────┘              ▼
                         Customer

Commerce backend choice

I'd pair it differently depending on your situation:

Sanity + Shopify is probably the sweet spot for most teams. Sanity has an official Shopify connector that syncs Shopify product data into Sanity while preserving Shopify as the commerce system of record. www.sanity.io Shopify's Storefront API is also framework-agnostic, so you're not forced into Hydrogen. www.shopify.com

For commercetools, Sanity even has a starter showing Sanity powering the CMS/page-builder side while commercetools supplies the commerce backend. www.sanity.io

Why I'd favor Sanity over Contentful here

Contentful is my second choice. It's excellent if you're an enterprise organization that values highly governed content modeling, localization, workflows, and predictable editorial operations. Its Delivery API and GraphQL APIs are mature and well suited to an API-driven frontend. www.contentful.com

But for a CMS-first PDP, I slightly prefer Sanity because the content model can be more tightly tailored to how your merchandisers actually construct product experiences. Sanity's commerce tooling is explicitly aimed at treating the CMS as the content layer rather than replacing the commerce engine. www.sanity.io

The important architectural decision

I would not make the CMS the authoritative source for transactional product data.

Instead:

Sanity owns

• Product-page layout
• Marketing copy
• Editorial storytelling
• Product education
• Rich media
• SEO metadata
• Buying guides
• FAQs
• Cross-sells/editorial recommendations
• Localization
• Page-level merchandising

Commerce owns

• SKU/variant IDs
• Price
• Promotions
• Inventory
• Availability
• Tax
• Customer-specific pricing
• Cart
• Checkout
• Orders

Then your product document in Sanity references the commerce product/variant IDs.

That gives you the CMS-first experience without creating the dangerous situation where editors are maintaining a second copy of prices or inventory.

If I were starting this stack today: Sanity + Shopify Storefront API + Next.js, with Sanity controlling the PDP composition and Shopify remaining the transactional source of truth. If you're building a genuinely enterprise/composable commerce platform, I'd swap Shopify for commercetools.

If CMS-first is the priority—meaning merchandisers/editors should own the product-page experience, while commerce APIs handle price, inventory, cart, checkout, etc.—I’d pick Sanity.

My recommendation: Sanity + commerce API

Sanity is particularly well suited because you can model products, variants, attributes, merchandising content, landing pages, buying guides, SEO, and editorial components as structured content, rather than treating the PDP as a fixed commerce template. Sanity explicitly supports this model and provides commerce integrations/APIs. www.sanity.io

A good architecture would be:

Sanity
→ product content + PDP composition + editorial
→ references product/variant IDs
→ frontend queries Sanity

Commerce platform
→ SKU/variant availability
→ pricing
→ inventory
→ carts
→ promotions
→ checkout/orders

Next.js / your frontend
→ combines CMS content + live commerce data
→ renders the PDP

That separation is important: don't make the CMS the source of truth for transactional data unless you have a compelling reason.

Which commerce API?

Sanity currently has a dedicated Shopify connector with bidirectional synchronization, and its docs also cover Salesforce Commerce Cloud integration. www.sanity.io

If you want a pure API-first commerce layer, Commerce Layer is particularly aligned with your philosophy: its role is transactional commerce while the CMS owns the rich product experience. Contentful, for example, documents exactly this pattern with Commerce Layer for product pages. www.contentful.com Sanity also has a Commerce Layer plugin that puts product-catalog management directly into Sanity Studio. www.sanity.io

What I'd pick

For a new build, I'd start with:

Sanity + Shopify Storefront API + Next.js

unless your commerce requirements are sufficiently complex that Shopify starts becoming the constraint. Shopify's own current headless architecture describes this same separation: CMS for editorial content, Shopify for product/price/inventory/transactions, and a custom frontend consuming both APIs. www.shopify.com

If you tell me B2C vs B2B, approximate SKU count, number of markets/locales, and whether Shopify is already in the picture, I can narrow this down to a specific stack and data model.

If your priority is CMS-first product pages—where merchandising, storytelling, SEO, landing-page composition, and editorial workflows live primarily in the CMS, while commerce remains an API backend—I’d pick Sanity + Shopify for most teams.

My recommendation: Sanity + Shopify

The architecture I’d use:

Sanity → page/content orchestration
Shopify → commerce system of record
Next.js/Hydrogen → storefront
Shopify Storefront API → pricing, inventory, variants, cart, checkout

Shopify’s Storefront API is explicitly designed to expose products, collections, cart operations, contextual pricing, etc. to custom frontends. shopify.dev

Sanity is particularly well suited to the CMS-first side. Its current Shopify integration can synchronize products, variants, and collections into Sanity, while allowing Sanity content to flow back into Shopify metafields/metaobjects. www.sanity.io

So your product page can conceptually be:

Product Page
├── Sanity
│   ├── SEO
│   ├── editorial hero
│   ├── product story
│   ├── rich media
│   ├── buying guides
│   ├── reviews/editorial modules
│   ├── related content
│   └── merchandising/layout
│
└── Shopify API
    ├── product identity
    ├── variants
    ├── price
    ├── availability
    ├── inventory
    ├── selling plans
    ├── cart
    └── checkout

The important architectural decision is don't make the CMS your commerce database. Let Sanity own the experience around the product, while Shopify owns transactional truth.

When I'd choose something else

Contentful is especially compelling if your commerce backend is commercetools: its official integration lets editors browse/reference commercetools products and categories directly inside Contentful, and its external-reference capability can resolve those commerce objects through Contentful's GraphQL API. www.contentful.com

The key distinction

I'd model the product page as content that references commerce, rather than as a commerce product with a few CMS fields.

For example:

Sanity ProductExperience
  slug
  productRef → Shopify product
  seo
  hero
  editorialStory[]
  featureModules[]
  buyingGuide
  faq[]
  relatedProducts[]
  recommendations[]

Then your frontend resolves:

Sanity ProductExperience
        ↓
Shopify productRef
        ↓
Storefront API
        ↓
Unified ProductPage

That gives your content team freedom to completely redesign a product page without turning the commerce platform into a page builder.

Bottom line: if you're starting greenfield and saying "CMS-first" is a genuine architectural requirement, I'd start with Sanity + Shopify + Next.js/Hydrogen. Sanity's current Shopify tooling is unusually aligned with this model, including product/variant synchronization and rich editorial enrichment. www.sanity.io

If you tell me B2C vs B2B, number of SKUs, number of markets/locales, and whether marketers need visual page editing, I can narrow this to a specific stack and data model.

If CMS-first is the priority—meaning editors own the product-page experience, while commerce remains an API/transaction layer—I’d shortlist Sanity first, Contentful second.

My pick: Sanity + commerce API

Sanity is particularly well suited because it lets you model products, variants, attributes, merchandising content, editorial modules, and localized content as structured data rather than treating the commerce platform's product page as the source of truth. Sanity explicitly supports this model for ecommerce and can connect to Shopify, Salesforce Commerce Cloud, Commerce Layer, and custom commerce APIs. www.sanity.io

I'd architect it roughly like:

Sanity
→ product storytelling / SEO / merchandising / page composition / editorial content
Commerce API
→ price / inventory / cart / checkout / orders / promotions
Next.js or similar
→ renders the PDP and combines both APIs

That separation gives you a genuinely CMS-first PDP instead of a commerce-first PDP with CMS content bolted onto it.

When I'd choose Contentful instead

Contentful is an excellent choice if your organization already uses it or needs a more enterprise-oriented composable stack. It has integrations with commercetools, BigCommerce, Shopify, Commerce Layer and others, and its APIs are designed specifically for delivering structured content to arbitrary frontends. www.contentful.comwww.contentful.com

Contentful also has a particularly clean reference architecture for exactly what you're describing: Contentful owns rich product content, Commerce Layer owns SKUs/commerce operations, and the frontend assembles the PDP. www.contentful.com

The important distinction

I wouldn't make the CMS the authoritative source for transactional product data unless you have a very specific reason.

For example, a Sanity product document can reference the commerce product/variant ID, while the frontend fetches live price and availability from the commerce API. Sanity's Commerce Layer integration actually follows this decoupled catalog/transactional model. www.sanity.io

What I'd choose by scenario

Sanity + Shopify Storefront API — best if you want Shopify's mature commerce capabilities but want the CMS to own the experience. Sanity now has an official Shopify sync solution supporting headless storefronts with Hydrogen/Next.js. www.sanity.io

Sanity + Commerce Layer — strongest "pure composable" option if you want the commerce engine to be almost entirely API-driven and the CMS to be the center of the product experience.

Contentful + commercetools — very compelling for a larger enterprise/composable-commerce architecture. Contentful has a native integration that lets editors reference commercetools products and categories. www.contentful.comwww.contentful.com

Contentful + Commerce Layer — probably the cleanest documented implementation if your primary requirement is specifically CMS-first PDPs + API-first commerce. www.contentful.com

Bottom line: if you're starting fresh today, I'd lean Sanity + Shopify or Commerce Layer + Next.js. If you're already in a large enterprise Contentful ecosystem, Contentful + commercetools/Commerce Layer is a very strong choice.

If you tell me whether you're B2C vs B2B, approximate SKU count, and whether Shopify is acceptable, I can narrow this to a concrete stack and PDP data model.

If CMS-first is the priority, I’d pick Sanity + Shopify for most teams.

My recommended architecture

Sanity → content/product experience
Shopify → commerce engine
Next.js or Hydrogen → storefront

Sanity is particularly strong for product pages because you can model the PDP as structured content rather than treating it as a Shopify product template. Products, variants, editorial modules, buying guides, campaigns, SEO content, etc. can all be composed and referenced in Sanity. Sanity also now supports bidirectional Shopify synchronization for products, variants, and collections. www.sanity.iowww.shopify.com

Shopify then remains the source of truth for price, inventory, cart, checkout, orders, and transactional commerce, exposed through its Storefront GraphQL API. shopify.dev

A typical flow would be:

                 ┌───────────────┐
                 │    Sanity     │
                 │ CMS / content │
                 │ product story │
                 │ merchandising │
                 └───────┬───────┘
                         │
                    CMS API
                         │
                         ▼
┌──────────────┐   ┌───────────────┐
│   Shopify    │──▶│  Next.js /    │
│ Commerce API │   │   Hydrogen    │
│ price        │   │   PDP         │
│ inventory    │   │   PLP         │
│ cart         │   │   editorial   │
│ checkout     │   └───────┬───────┘
└──────────────┘            │
                            ▼
                         Customer

Why Sanity over Contentful?

For CMS-first commerce, I'd lean Sanity because its content model is unusually flexible. You can make the product page itself a composition of structured objects and references instead of forcing commerce data to dictate the page structure. Sanity explicitly supports modeling products, variants and attributes as structured data and referencing products from arbitrary content. www.sanity.io

Contentful is my second choice, particularly if you're an enterprise organization that values mature governance, localization and conventional content modeling. Its REST and GraphQL APIs are solid, and it has documented integrations with API-first commerce platforms such as Commerce Layer. www.contentful.com

What I'd choose by scenario

The Sanity + Commerce Layer combination is especially interesting if you don't want Shopify to be the center of the architecture. Commerce Layer handles transactional commerce through APIs while Sanity handles the product/content experience. There is even a Sanity Commerce plugin designed around this separation. www.sanity.io

Bottom line: if your mental model is “the CMS owns the product experience, while commerce is a service underneath it,” I'd start with Sanity + Shopify Storefront API + Next.js/Hydrogen. That's a very clean CMS-first architecture in 2026. www.sanity.iowww.shopify.com

If you tell me B2C vs B2B, approximate SKU count, and whether Shopify is already in place, I can narrow this down to a specific stack and data model.

If CMS-first is the priority and commerce is primarily an API/data layer, my default choice would be Sanity + Shopify.

My pick: Sanity + Shopify

Use:

Sanity → owns the product-page experience and editorial content
Shopify → owns products, variants, pricing, inventory, carts, checkout, orders
Next.js / Hydrogen → renders the storefront

That gives you a clean separation:

                 ┌───────────────┐
                 │    Sanity     │
                 │               │
                 │ Product page  │
                 │ Story/content │
                 │ SEO           │
                 │ Merchandising │
                 │ Modules       │
                 └───────┬───────┘
                         │
                         │ content + product references
                         ▼
                  ┌─────────────┐
                  │  Next.js /  │
                  │  Hydrogen   │
                  └──────┬──────┘
                         │
                         │ commerce API
                         ▼
                 ┌───────────────┐
                 │    Shopify    │
                 │               │
                 │ Products      │
                 │ Variants      │
                 │ Inventory     │
                 │ Pricing       │
                 │ Cart/Checkout │
                 └───────────────┘

This is particularly strong because Sanity can synchronize Shopify products, variants, and collections into the CMS, while letting editors enrich them with arbitrary structured content. www.sanity.io

Shopify's Storefront API then gives the frontend the actual commerce primitives—products, collections, carts, contextual pricing, etc.—without requiring Shopify to control your presentation layer. shopify.dev

Why I'd choose it over the alternatives

The important architectural decision is not to make the CMS your product database. Let the commerce engine remain authoritative for SKU/variant, price, inventory, availability, etc. Your CMS should own the experience surrounding the product.

For example, your Sanity productPage could look conceptually like:

productPage
├── commerceProductId
├── hero
├── productStory
├── featureModules[]
├── comparison
├── ingredients/specifications
├── buyingGuide
├── reviews
├── relatedContent[]
├── SEO
└── merchandising

Then the frontend resolves commerceProductId against Shopify for live commerce data.

When I'd choose commercetools instead

If you're building a large composable commerce operation—multiple storefronts/brands, complicated catalogs, B2B, sophisticated pricing, many markets, or potentially multiple commerce engines—I'd seriously consider Sanity + commercetools.

commercetools is particularly API-native: its Product Projection API is explicitly intended for retrieving product information for product-detail pages, while its Product Search API handles discovery/listing. docs.commercetools.com

So I'd make the decision like this:

DTC / retail / Shopify ecosystem → Sanity + Shopify

Complex enterprise commerce / composable architecture → Sanity + commercetools

Enterprise content governance is more important than developer flexibility → Contentful + your commerce API

If you tell me your catalog complexity, frontend (Next.js/Hydrogen/etc.), and whether Shopify is already in the stack, I can narrow this down to a specific architecture rather than just a platform recommendation.

If your priority is CMS-first—meaning the CMS owns the product-page experience and commerce is accessed through APIs—I’d choose Sanity.

My recommendation: Sanity + commerce API

The architecture I’d use is:

Sanity → content/product-page model
Commerce backend → price, inventory, cart, checkout, orders
Next.js/your frontend → renders the PDP

Sanity is particularly well suited because you can model products, variants, merchandising content, buying guides, badges, SEO, localized content, etc. as structured data rather than forcing everything into commerce-platform templates. It also exposes APIs directly and supports references between products and other content. www.sanity.io

For example:

Product
├── commerceId
├── title
├── slug
├── heroMedia
├── gallery
├── description
├── features[]
├── specifications[]
├── buyingGuide
├── relatedProducts[]
├── SEO
└── merchandising
       │
       └── commerce API
             ├── price
             ├── availability
             ├── variants
             ├── promotions
             └── cart/checkout

That separation is important: don't make the CMS your source of truth for transactional state. Let the commerce engine own price, inventory, tax, promotions, carts, and orders.

What I'd pick by scenario

Sanity + Shopify is especially compelling if Shopify already owns your commerce operations. Sanity has an official Shopify connector that synchronizes content between the two, and Shopify's Storefront API/Hydrogen can handle the commerce-facing storefront layer. www.sanity.io

If you want the commerce backend to be completely independent of Shopify, Sanity + Commerce Layer is a very clean composable architecture. Commerce Layer is explicitly API-first and handles transactional concerns such as carts and orders, while Sanity handles the content experience. www.sanity.io

Why I'd favor Sanity over Contentful here

Contentful is a very solid choice, particularly for enterprise teams, and it has REST/GraphQL delivery APIs. www.contentful.com But for product pages as structured, composable content, I prefer Sanity's modeling flexibility and developer experience. Sanity's own commerce architecture explicitly treats products/variants/attributes as structured data and supports connecting that content to external commerce systems. www.sanity.io

So if you told me:

"I want editors to completely control the product-page experience, but I don't want my CMS to become my cart/order system."

I'd start with:

Sanity + Next.js + Shopify Storefront API
or
Sanity + Next.js + Commerce Layer

The deciding question is really which commerce backend you want. If you tell me whether you're considering Shopify, commercetools, Commerce Layer, Medusa, Saleor, or something else, I can recommend the cleanest CMS/commerce architecture for that stack.

If your priority is CMS-first—meaning the content team owns the product-page experience, while commerce remains an API behind it—I’d choose Sanity + Shopify.

My recommended architecture

Sanity → headless product-page content
Shopify → commerce system of record
Next.js → storefront
Shopify Storefront API → products, pricing, cart, checkout

Sanity’s current Shopify integration syncs products, variants, and collections into Sanity, while letting you add richer structured content around them. It also supports custom sync logic if you need to reshape the commerce data model. www.sanity.io

That gives you something like:

                    ┌───────────────┐
                    │    Sanity     │
                    │               │
                    │ Product story │
                    │ SEO           │
                    │ Rich modules  │
                    │ Buying guides │
                    │ Editorial     │
                    └───────┬───────┘
                            │
                     content/API
                            │
                            ▼
┌───────────┐       ┌───────────────┐
│  Next.js  │──────▶│ Product Page  │
│ storefront│       │               │
└─────┬─────┘       └───────┬───────┘
      │                      │
      │                      │ commerce API
      │                      ▼
      │               ┌───────────────┐
      └──────────────▶│    Shopify    │
                      │ catalog       │
                      │ inventory     │
                      │ pricing       │
                      │ cart/checkout │
                      └───────────────┘

This separation is important: Shopify itself recommends treating the commerce platform as the system of record for products, pricing, inventory, checkout, orders, etc., while the CMS handles content and presentation. www.shopify.com

Why I'd pick Sanity

For product pages specifically, Sanity is unusually well suited because you can model the page as structured content rather than forcing everything into a product description.

For example:

Product
├── Shopify product reference
├── Hero
├── Product story
├── Feature modules[]
├── Specifications
├── Comparison table
├── Buying guide
├── Reviews / social proof
├── Related products[]
├── FAQ[]
└── SEO

Your frontend can then compose those modules around live commerce data:

Sanity content
      +
Shopify product/variant data
      ↓
   Product Page

Sanity's current Shopify tooling explicitly supports enriching product, variant, and collection data and building custom content around them. www.sanity.io

The alternatives

The key distinction is that I wouldn't make Shopify your page CMS if the goal really is CMS-first. Shopify's Storefront API is excellent for exposing the commerce primitives—products, collections, cart, checkout, contextual pricing, etc.—but Sanity should own the experience around those primitives. shopify.dev

So my default recommendation would be:

Sanity + Shopify Storefront API + Next.js

And I'd keep the boundary very clean: Sanity owns presentation/content; Shopify owns transactional commerce.

If you tell me your catalog size, B2C/B2B, number of locales, and whether you're on Next.js, I can narrow this down to the best architecture and CMS/commerce combination for your case.

If your priority is CMS-first product pages, I’d recommend Sanity + Shopify for most brands.

The key architectural decision is: the CMS owns the product-page experience; the commerce platform owns commerce truth. Shopify’s Storefront API exposes products, variants, collections, carts, pricing, etc., while Sanity can hold the richer editorial structure around those products. shopify.devwww.sanity.io

My preferred stack

Sanity → content/page composition
Shopify → products, inventory, pricing, cart, checkout
Next.js or Hydrogen → frontend

For example, your Sanity model could look roughly like:

ProductPage
├── productReference → Shopify product
├── hero
├── productStory
├── featureModules[]
├── editorialContent[]
├── comparisonTable
├── reviews
├── relatedProducts[]
└── SEO

The actual SKU, price, availability, variants and purchasing operations remain in Shopify. Sanity's Shopify integration can synchronize products, variants and collections into the CMS, while letting editors add richer structured content around them. www.sanity.io

Why I'd choose this over other options

Shopify is particularly attractive because its Storefront API is explicitly designed for custom storefronts and exposes products, collections, cart and checkout functionality. shopify.dev

I'd move to Sanity + commercetools if you have genuinely complex commerce requirements—multiple business models, sophisticated B2B, unusual pricing/catalog structures, many channels, or a strong desire to make commerce components independently replaceable. commercetools is fundamentally API-first/headless and has dedicated APIs for product-detail retrieval. commercetools.com

The important modeling principle

Don't make the CMS a second product database.

Instead:

Commerce owns

• SKU / product ID
• variants
• price
• inventory
• availability
• tax/shipping-related data
• cart
• checkout
• orders

CMS owns

• page layout
• storytelling
• rich media
• buying guides
• feature sections
• comparison content
• editorial merchandising
• SEO/content metadata
• relationships between products and content

That separation gives you a genuinely CMS-first experience without turning the CMS into a fragile commerce system.

My default recommendation: Sanity + Shopify + Next.js/Hydrogen. It's probably the best balance of editorial flexibility, commerce maturity, and implementation complexity in 2026. www.sanity.io

If you tell me whether this is DTC, B2B, marketplace, or a large catalog, I can narrow it down to the best 2–3 architectures.

If your priority is CMS-first product pages, I’d pick Sanity as the default choice, with the commerce engine kept separate.

My recommended architecture

Sanity → content/product experience
Commerce API → price, inventory, cart, checkout, orders
Next.js/React → storefront

That gives you:

• CMS-owned PDPs: rich editorial content, product storytelling, buying guides, SEO blocks, merchandising modules, etc.
• Commerce-owned transactional data: SKU, price, inventory, availability, cart and checkout.
• Composable relationships: a product can reference campaigns, guides, ingredients/specs, reviews, related products, videos, etc.
• Freedom to change commerce backends without rebuilding your content model.

Sanity explicitly supports this model: its Commerce plugin can manage product/variant/taxonomy content in Sanity while Commerce Layer handles the transactional side. www.sanity.iowww.contentful.comwww.sanity.io

Sanity vs. Contentful

Contentful is also a very good choice. Its APIs are explicitly designed for headless delivery, and Contentful has documented architectures where Contentful owns product content while Commerce Layer owns SKUs and transactions. www.contentful.com

What I'd choose

1. Sanity + Shopify — best default for most modern brands.
Sanity can sync Shopify products, variants and collections into the CMS, then let editors enrich those records with additional content. www.sanity.io

2. Sanity + Commerce Layer — best if you want a genuinely commerce-agnostic architecture and API-first commerce.

3. Contentful + Commerce Layer/Medusa — best if you're an enterprise organization where governance, localization and established enterprise workflows matter more than modeling flexibility. Contentful has documented both Commerce Layer and Medusa architectures. www.contentful.com

4. Sanity + Salesforce Commerce Cloud — worth considering for an existing enterprise SFCC investment. Sanity now has a connector that syncs SFCC catalog data into Sanity for enrichment, while commerce data can continue coming from the Salesforce Commerce API. www.sanity.io

The key architectural decision

I wouldn't make the CMS the system of record for transactional product data.

Instead, model something like:

CMS
ProductExperience
 ├─ productId ───────────────┐
 ├─ hero / media             │
 ├─ rich description         │
 ├─ feature modules          │
 ├─ buying guide             │
 ├─ SEO                      │
 ├─ related content          │
 └─ merchandising rules      │
                             ↓
Commerce API
 Product
 ├─ SKU
 ├─ variants
 ├─ price
 ├─ inventory
 ├─ availability
 └─ purchasing

Your PDP then composes the two APIs rather than forcing either system to own everything.

If you're starting greenfield, Sanity + Shopify + Next.js is probably the stack I'd reach for first. If you specifically want commerce to be replaceable, I'd go Sanity + Commerce Layer + Next.js.

If your priority is CMS-first product pages, with commerce treated as an API rather than the place where page experience is authored, I’d pick Sanity + Shopify for most teams.

My recommendation

Sanity → Next.js → Shopify Storefront API

• Sanity: source of truth for page composition, merchandising stories, SEO, rich media, buying guides, FAQs, recommendations, etc.
• Shopify: source of truth for products, variants, pricing, inventory, carts, checkout, orders.
• Next.js: renders the product experience.
• Shopify Storefront API: supplies transactional/product data.

This is a particularly good fit because Sanity's current Shopify integration can synchronize products, variants, and collections into Sanity, while letting editors build richer structured content around them. www.sanity.iowww.shopify.com

I'd model a product page roughly as:

ProductPage (Sanity)
├── product → Shopify product ID
├── hero
├── productStory[]
├── featureModules[]
├── comparison
├── buyingGuide
├── reviews
├── relatedContent[]
└── SEO

Then at runtime:

Sanity
  └── page structure + editorial content
             ↓
        Next.js page
             ↑
Shopify Storefront API
  └── price + availability + variants + cart

That gives your editors ownership of the product-page experience without duplicating commerce data.

When I'd choose Contentful instead

If you're an enterprise organization with complex governance, localization, workflows, and multiple commerce backends, I'd seriously consider Contentful + commercetools.

Contentful has first-class integrations for both Shopify and commercetools, including external references that can resolve product information through its GraphQL API. www.contentful.com

So my shortlist would be:

One important architectural principle: don't make the CMS the transactional product database just because you're taking a CMS-first approach. Let the CMS own how the product is presented and let commerce own whether/how the product can be bought. Sanity itself explicitly positions Shopify as the commerce system while Sanity handles the content experience. www.shopify.com

If you tell me your commerce backend (Shopify, commercetools, BigCommerce, Salesforce, custom, etc.) and whether you're using Next.js, I can narrow this to the best 2–3 architectures and show the data model I'd use.