What is Online Store 2.0?

How it works

Online Store 2.0 rests on three interlocking concepts: JSON templates, section groups, and a block-based content model. JSON templates replace the previous .liquid template files. Instead of templates/product.liquid containing rendering logic, a templates/product.json file declares which sections appear on a product page and stores their initial settings. The actual rendering logic lives in sections files. Because the template is data — not code — Shopify can store per-product, per-collection, or per-page layout overrides without any code changes.

Section groups extend the sections model to layout areas that are shared across pages — primarily the header and footer. Instead of hard-coding {% section 'header' %} in layout/theme.liquid, the layout uses {% sections 'header-group' %} — a group of sections managed as a single editable unit in the theme customiser. Merchants can add an announcement bar, a promo banner, or a navigation bar to the header group without touching code.

Blocks are the smallest unit of the content model. Each section can define named block types in its {% schema %}. On the product page, typical blocks include a title block, price block, variant selector block, description block, and buy button block. Merchants can reorder these blocks freely, remove ones they don't need, and add app-supplied blocks from installed Shopify apps.

Why it matters

For merchants, Online Store 2.0 means genuine no-code control over storefront layout. Before OS 2.0, a merchant who wanted to move the size chart above the Add to Cart button had to file a support request with their development agency. After OS 2.0, they drag the size chart block above the buy button in the theme editor and save. This reduction in development dependency has directly lowered the cost of running a Shopify store, because routine layout adjustments no longer require agency billing hours.

For developers, OS 2.0 creates a cleaner separation between code and content. Theme code defines what's possible (the section types, block types, and settings). Content is data stored in JSON files, edited through the customiser. This separation means merchants can customise extensively without creating git conflicts, and developers can deploy theme code updates without overwriting merchant configuration.

The app ecosystem also benefits. Theme App Extensions — the mechanism apps use to inject UI into storefronts — require OS 2.0. Any app offering a "no-code embed" feature (review carousels, loyalty widgets, custom upsell blocks) is only able to offer that experience because OS 2.0 standardised the block interface. Apps installed on OS 1.0 themes are forced to use Script Tags, which are slower, harder to configure, and less integrated with the theme editor.

How it differs from Online Store 1.0

In Online Store 1.0, sections existed only on the homepage. Every other page — product, collection, blog, cart — was rendered by a Liquid template file with static structure. You could add a section to the homepage via the theme editor, but the product page was whatever the Liquid file hard-coded. Customising it required editing templates/product.liquid directly — a code-level operation. Merchants without development knowledge could not make layout changes on product pages.

In Online Store 2.0, sections are first-class on every page type. A product page template is a JSON file that lists sections; each section supports blocks; each block is configurable and reorderable. The theme editor works the same way on a product page as it does on the homepage. Merchants see the same drag-and-drop customiser regardless of the page type they're editing.

Another meaningful difference is per-page template assignment. In OS 1.0, all products used the same templates/product.liquid layout (with alternative templates requiring duplicate product.alternate.liquid files). In OS 2.0, you create templates/product.json and additional templates/product.feature.json, templates/product.preorder.json etc. Merchants assign these templates per-product from the product detail page without any code changes.

Should you migrate your theme?

If you are building a new theme from scratch, there is no decision to make — build with OS 2.0 architecture from day one. The Dawn reference theme is the right starting point; all of Shopify's platform documentation and new feature development assumes OS 2.0.

If you are maintaining an existing OS 1.0 theme and a merchant asks why they can't drag-and-drop their product page, migration is worth the investment. The migration is not trivial — it requires converting template files to JSON and moving rendering logic to section files — but it's a one-time cost. After migration, ongoing theme maintenance is simpler because code and content are cleanly separated.

Shopify has not deprecated OS 1.0 themes — existing themes continue to work. But new platform features consistently require OS 2.0. Metaobject rendering in the theme editor, certain dynamic source bindings, and app blocks from modern apps will not function in an OS 1.0 theme. Staying on OS 1.0 is a form of technical debt that compounds with each new Shopify feature release.

Key technical changes for developers

Several concrete technical changes accompany the OS 2.0 architecture. The image pipeline moved from the deprecated img_url filter to image_url with the accompanying image_tag filter for automatic srcset and lazy loading. The section rendering tag gained a block iteration pattern: sections loop over section.blocks and render each with a case block.type statement. The content_for_header and content_for_layout tags remain in layout/theme.liquid — these are not OS 2.0 additions but are unchanged and still required.

Metafields received first-class support in OS 2.0 via pinned definitions (Settings > Custom data) and the dynamic source mechanism in section settings. Before OS 2.0, accessing metafields in Liquid required workarounds like the all_products global or was limited to Liquid objects exposed through the theme context. OS 2.0 standardised product.metafields.namespace.key.value as the canonical access pattern, backed by typed definitions with storefront access control. Metaobjects — the structured content type introduced in Summer 2022 as an extension of this metafield system — are only accessible to themes built on the OS 2.0 template and section architecture.

Theme Check — Shopify's official Liquid linter — was updated alongside OS 2.0 to validate section schemas, flag deprecated filters, and enforce correct block structure. Running shopify theme check on an OS 2.0 theme gives you a report on schema validity, missing translation keys, and any uses of the img_url filter (which should be replaced with image_url). Building Theme Check into your CI pipeline is strongly recommended for any OS 2.0 theme in active development.