Platform Deep Dive

Shopify Online Store 2.0: Architecture, Sections, JSON Templates & When to Migrate

A focused merchant- and developer-facing guide to Shopify Online Store 2.0 — the four primitives, metafields and dynamic sources, OS 2.0 vs Vintage, honest limits, Horizon vs Dawn, the migration path that actually works, and realistic cost paths.

May 30, 2026·18 min read·
Listen to a short brief of this article
Hands-free while you multitask

Key Insights in 60 Seconds

Skim the highlights, then jump to the section that matches your role and situation.

OS 2.0 = sections everywhere — every page is a stack of editor-controlled blocks, not just the homepage.
JSON templates replace fixed Liquid pages and unlock app blocks and drag-and-drop ordering.
Metafields plus dynamic sources retire most custom Liquid for spec tables and PDP detail.
OS 2.0 is not checkout — checkout extensibility is a separate system on Shopify and Plus.
30-second diagnostic — if your editor reorders sections on the product page, you're on OS 2.0.
Vintage is not deprecated — migration is optional, but new features ship to OS 2.0.
Markets and B2B run natively on OS 2.0; Hydrogen stays optional, not default.
Migration breaks at custom Liquid, not content — port snippets to sections before swapping templates.

What You'll Learn

1What OS 2.0 is, plainly
2Sections, JSON templates, app blocks
3Metafields and dynamic sources
4OS 2.0 vs Vintage day-to-day
5Horizon vs Dawn in 2026
6Markets, B2B, Headless fit

What Online Store 2.0 Actually Is

Online Store 2.0 (OS 2.0) is the name Shopify gave to the 2021 overhaul of its theme architecture. It is not a separate Shopify plan, a new admin or a different storefront product — it is the set of changes that turned themes from mostly-fixed Liquid files into composable, editor-driven, app-extensible documents. Every theme in the Shopify Theme Store is now OS 2.0, and so are all of Shopify's free reference themes — including the current flagship, Horizon.

The clearest way to grasp what changed is to look at what came before. Pre-2.0 themes — now called Vintage themes — could only assemble the homepage through the theme editor. Every other template (product page, collection page, blog post, cart) was a fixed Liquid file. Merchants who wanted a different product page had to edit theme code or pay a developer. OS 2.0 turned each template into a JSON object that lists which sections render, in what order, with which settings — all editable from the admin, with no code.

Upgrading to Online Store 2.0 isn't mandatory. Merchants can continue using a vintage theme if it meets their needs.
Shopify Developer Documentation — Online Store 2.0 · View source (shopify.dev)

That sentence is more important than it looks. It frames the migration question correctly: OS 2.0 is not a forced upgrade, but new features are shipping to OS 2.0 first and the long-term direction of the platform is clear. If you are evaluating a re-platforming budget, the right question is when, not whether. The rest of this guide gives you the architecture, the trade-offs, the migration plan and the cost paths so you can make that call.

If you are coming in cold and want a more general theme primer first, the Shopify theme guide explains how themes, templates and the editor work end-to-end. If you are evaluating Liquid as a language, the Liquid explainer goes deeper on syntax. This article focuses specifically on the OS 2.0 architecture itself.

Online Store 2.0: Building themes on Shopify | Shopify Unite 2021Shopify's original announcement and architecture walkthrough of Online Store 2.0 — sections on every page, JSON templates, app blocks, and metafields. The canonical primary-source overview from Shopify's developer team.

The Four Primitives That Run OS 2.0

OS 2.0 is best understood not as a feature list but as four primitives that compose into everything else. Each one solves a specific problem with how Vintage themes worked, and together they redefine what is editable, what is reusable and where customisation lives.

Sections everywhere
Before OS 2.0, only the homepage could be assembled in the theme editor — every other page was a fixed Liquid file. OS 2.0 makes every page (product, collection, cart, blog, custom) a stack of merchant-controlled sections that can be added, reordered or removed without code.
JSON templates
Templates are no longer monolithic Liquid files but JSON objects that list which sections render and in what order. The same product template can be reused across SKUs while a one-off product gets its own template — switched per product from the admin.
App blocks (theme app extensions)
Apps install UI as theme blocks via theme app extensions instead of injecting <script> tags or rewriting Liquid. The merchant adds, hides or moves the app's UI from the theme editor; uninstalling the app removes the block cleanly with no orphaned markup.
Metafields & dynamic sources
Custom structured data (spec tables, ingredients, size guides, badges) lives in metafields and is bound to section settings through dynamic sources in the theme editor. The merchant fills a field; the section renders. Custom Liquid for routine PDP content largely goes away.

A fifth piece — section groups — extends the first primitive to the header and footer. Section groups let merchants add sections (announcement bars, secondary nav, promo strips) into the header or footer area through the same editor surface, instead of editing layout files. Combined with the four primitives above, the storefront has effectively zero hard-coded regions left.

Why this matters operationally
Every primitive above moves work from developer time to editor time. A change that used to require a Liquid edit, a Git commit and a theme preview now lives in a settings panel. That doesn't make developers obsolete — bespoke sections, custom apps and performance work still need code — but it raises the floor of what a non-technical merchant can ship on their own.

Metafields & Dynamic Sources: The No-Code Data Layer

Before OS 2.0, anything beyond Shopify's built-in product fields — spec tables, ingredients, country of origin, downloadable manuals, size guides, custom badges — was a Liquid edit. Developers added a snippet, hard-coded the layout, and any future change went back through the same developer. Multiply that by a few hundred products and the maintenance cost was real.

Metafields moved the custom-data definition into the admin. Dynamic sources made those metafields bindable directly inside the theme editor — a section setting that previously held a literal string can now point to a metafield. The merchant fills the field on each product; the storefront renders. The Liquid snippet disappears.

How metafields and dynamic sources move custom content from developer-owned Liquid into admin-owned settings.

Practically, this changes who owns three jobs across the content lifecycle:

JobOwnerWhere the work happens
Schema designDeveloper / solutions architectAdmin: define which metafields exist, types, admin display
Section designTheme developerTheme code: build reusable sections with dynamic-source-friendly settings
Content entryMerchant teamProduct / collection / page admin — no theme code touched

This separation is the OS 2.0 win that delivers the most ongoing value, because content entry is the job done every week. The other primitives matter at re-platforming time; metafields plus dynamic sources matter every day.

OS 2.0 vs Vintage Themes: What Changes Day-to-Day

Feature lists undersell the difference. The right comparison is operational: for the changes you actually make every month, which architecture forces you back into code?

Day-to-day taskVintageOS 2.0
Rearrange homepage sectionsEditor (limited)Editor
Customise a product page layoutDeveloper (Liquid edit)Editor (sections everywhere)
Different layout per productDuplicate template + Liquid editNew JSON template, assigned per product
Add an app's UI to product pagePaste app's Liquid snippetAdd app block in editor
Show ingredients or specsCustom Liquid + product description hackMetafield + dynamic source
Add an announcement barEdit theme.liquidSection group in header
Remove an uninstalled app's leftoversManual cleanup of snippetsAutomatic — block disappears with the app
Build a landing pageCustom page template (Liquid)Custom JSON template + sections

Across every row, the pattern is the same: tasks that needed a developer in Vintage now belong to the merchant in OS 2.0. That is the actual product story — not new visuals, but a shorter loop between "we want to change this" and the change shipping.

What OS 2.0 Still Does Not Do

It is more useful to know where OS 2.0 stops than to memorise what it covers. Four limits matter in practice — each one is a real constraint that has bitten merchants mid-migration.

Checkout is a separate system
OS 2.0 governs the storefront only. Checkout customisation runs on checkout extensibility — checkout UI extensions installed via apps work on every Shopify plan, while replacing checkout.liquid and shipping custom checkout apps is restricted to Shopify Plus. Either way, it sits outside the OS 2.0 architecture you edit in the theme editor.
No server-side state in sections
Sections render in Liquid against request-time data — there is no persistent component state, no per-user server logic in the theme. Anything stateful (saved carts, gated content, dynamic eligibility) still ships as an app or a Storefront-API frontend.
Performance debt from over-stacking
Every section is a JavaScript surface. Themes stuffed with 20 third-party app blocks degrade LCP and CLS measurably. OS 2.0 makes the stacking easy; the discipline to remove unused blocks is on the merchant.
Some vintage features don't auto-port
Custom Liquid snippets, hard-coded JSON-LD, bespoke section schemas, and theme-edited app integrations from a Vintage theme do not migrate automatically. They need re-implementing as OS 2.0 sections or theme app extensions.

If checkout customisation is on the roadmap, the rules live in a separate Shopify framework — see checkout UI extensions for what apps can change on every plan, and the broader checkout extensibility docs for the Plus-only surface. Neither lives inside the OS 2.0 theme editor.

The performance trap
OS 2.0's editor convenience makes it trivial to keep adding app blocks. Each one ships JavaScript, CSS and request overhead. Audit the storefront with Shopify's theme performance best practices and remove blocks you are not using — not when speed becomes a problem, but on a regular cadence. The architecture rewards discipline.

How to Tell If You're Already on OS 2.0

Before scoping any migration, confirm what you're actually on. Many merchants assume they're on Vintage because their theme looks dated — but a theme bought in 2019 from the Theme Store may have been kept up-to-date by its vendor and is now an OS 2.0 build. The architecture is independent of the visual design.

Run these three checks in your Shopify admin. If all three pass, you're on OS 2.0. If any fail, you're on a Vintage theme — or on an OS 2.0 theme that hasn't been updated to the latest features.

  1. The product-page editor test. Open Online Store → Themes → Customize and switch the editor preview from the homepage to a product template. If you can add, remove and reorder sections on the product page, you're on OS 2.0. If the page is a fixed layout with only a few hard-coded settings, you're on Vintage.
  2. The app block test. In the same editor, open any section and click Add block. If you see app-installed blocks listed alongside theme blocks (review widgets, upsell cards, etc.), the theme supports theme app extensions — an OS 2.0 signal. Vintage themes have no concept of app blocks.
  3. The metafield binding test. Open any section setting in the editor that accepts text. If a small database icon appears next to the input and lets you "connect to dynamic source", the theme supports dynamic sources — another OS 2.0 signal.
Bonus check: the theme file structure
If you have a developer or comfort with code, download the theme and look in /templates/. If the files end in .json, it's OS 2.0. If they all end in .liquid, it's Vintage. A mix usually means a partially-migrated theme that needs cleanup.

The outcome of this 30-second audit changes the next steps entirely. If you're on OS 2.0, the action is to update to the latest theme version, evaluate whether to move to Horizon (covered next), and audit unused sections. If you're on Vintage, the action is the migration project covered further below.

Horizon vs Dawn: The 2025 Flagship Shift

For four years, Dawn was the answer to "which theme should I start with?" In 2025 Shopify shipped Horizon as the new flagship, with a refreshed editor experience, generative block options, and a faster default performance budget. Both themes are OS 2.0 to the core, so the choice is about which editor surface and which design language fits the brand — not about architecture.

Polished design meets a clean setup: launch faster without sacrificing style.
Shopify Theme Store — Horizon theme listing · View source (themes.shopify.com)
Shopify Editions Summer '25 — New theme foundation: HorizonShopify's official 2-minute introduction to the Horizon theme — design freedom, buyer optimizations, built-in AI, and the new theme editor experience. Direct from Shopify's Editions launch.
Vintage theme vs Dawn (OS 2.0) vs Horizon (OS 2.0 flagship)
FeatureVintageDawnMatureHorizon
ArchitectureSections only on homepageFull OS 2.0 (sections everywhere, JSON templates)Full OS 2.0 + AI-assisted theme blocks
Default for new storesNo (legacy)Shopify's flagship 2020–2024New flagship foundation since 2025
Theme editor experienceLimited per-page controlFull drag-and-drop on every templateDrag-and-drop + generative blocks
Section groups (header / footer)NoYesYes
Best fitExisting stores happy with current buildConservative builds that prioritise stabilityNew stores that want the newest editor surface

Horizon is the right default for stores launching now, with the caveat that any team with a long Dawn-based development history will move faster by sticking with what they know. The migration from Dawn to Horizon is real work — it is closer to a redesign than a version bump.

Premium themes count too
Don't read this section as "pick a free Shopify theme or nothing". Premium themes from the Theme Store are also OS 2.0 — the points in this article apply to them identically. The choice between free and paid is about design and bundled sections, not about OS 2.0 coverage.

Migration: When to Move and What Breaks

The biggest single mistake teams make is treating a Vintage-to-OS-2.0 move as a theme swap. It isn't. It is a re-platforming exercise inside Shopify, scoped by how much the current theme has been customised. A theme with stock Vintage Liquid migrates quickly; a theme with two years of bespoke snippets, custom JSON-LD blocks, and theme-edited app integrations is a real project.

Five phases keep that project under control. Do them in order — skipping the audit is what creates the all-night cutover horror stories.

1
Audit the current theme
Inventory every customisation: edited section files, custom snippets, hard-coded apps, theme-injected scripts, custom JSON-LD. Classify each as keep-as-is, port-to-section, or replace-with-app-block. This audit drives the entire migration scope.
2
Pick the target OS 2.0 theme
Default to Horizon for new builds and Dawn when the team needs a more mature reference theme. Paid OS 2.0 themes work too, but verify the vendor maintains it actively — abandoned premium themes are the most common post-migration regret.
3
Port content into sections and metafields
Rebuild PDP, collection and homepage content using the target theme's sections and metafield definitions. Custom HTML or Liquid blocks that previously lived inside templates become reusable sections, with editor settings instead of hard-coded values.
4
Re-install apps as theme app extensions
App compatibility is the single biggest migration risk. Before you start, open each installed app and check whether it ships an OS 2.0 app block (most major apps do — reviews, upsells, search, subscriptions, B2B, loyalty, reviews, bundles). For each app: remove the old theme-edited integration, re-install the app on the new theme, add its block where needed. Long-tail apps without blocks need a Liquid edit on the new theme — budget developer time for those. Abandoned apps are the trigger to replace them; do not migrate dead integrations.
5
QA, performance pass, then swap
Test on a duplicated unpublished theme: every template, every page type, every checkout path. Run a Lighthouse pass and remove unused app blocks before publishing. Schedule the swap during low-traffic hours and keep the previous theme one click away as a rollback.
When to migrate, not how
Migrate when at least one of these is true: you can name three or more recurring changes that need a developer today and would be editor-only on OS 2.0; an app you depend on has shipped an app block but you cannot use it on Vintage; or your current theme is unmaintained by its vendor. If none of the above hold, defer — Vintage still works.

For broader migration scenarios that involve moving to Shopify from another platform entirely (WooCommerce, Magento, BigCommerce), the platform migration guide covers SEO, data, and cutover patterns that apply on top of an OS 2.0 build.

Cost & Effort: Four Realistic Paths

The cost of an OS 2.0 build is mostly determined by how much custom work the current site carries, not by OS 2.0 itself. The architecture is the same across all four paths below; what changes is who does the work and how bespoke the result is.

PathTimeCostBest fit
DIY on a free OS 2.0 theme1–3 weeks part-time$0 software + ~20–60 hours of merchant timeSmall catalogue (<200 SKUs), no custom Liquid in the current theme, comfortable in the theme editor
Free OS 2.0 theme + paid sections2–4 weeks$100–$400 in section bundles + ~30–80 hoursWants a richer storefront than free sections offer, no developer on retainer
Premium OS 2.0 theme + light dev3–6 weeks$280–$420 theme + $1.5k–$6k dev for porting customisationsBrand-led store with bespoke PDPs, marketing pages, and a few app integrations to re-wire
Custom OS 2.0 theme by a developer6–14 weeks$8k–$40k+Distinct brand UX, complex merchandising, custom sections needed across PDPs and CMS-style landing pages

Two patterns hold across all four paths. First, the DIY ceiling is higher than people expect on OS 2.0 — sections everywhere plus metafields covers most merchant requests without any code. Second, the developer ceiling is also higher — bespoke sections built once become reusable, drag-and-droppable assets for the merchant team forever. Both ends of the spectrum get better economics from OS 2.0 than from Vintage.

Side budget items to factor in regardless of path: a paid metafield manager app if the catalogue is large, premium sections if the chosen theme is sparse, and a performance audit if the storefront ends up with more than a handful of third-party app blocks. If the build will include a developer, the Shopify developer hiring guide covers what to vet for; custom design choices covers the design side.

OS 2.0 with Markets, B2B & Headless

OS 2.0 is rarely the only Shopify surface a growth-stage merchant uses. Three platform capabilities show up in almost every re-platforming conversation. The table below summarises how each one fits with OS 2.0; the notes after expand the nuance.

CapabilityHow it works with OS 2.0When OS 2.0 alone isn't enough
Shopify Markets
(international)
Runs above the theme — currencies, languages, domains, duties. Horizon and Dawn ship language/currency/country blocks out of the box.Never — OS 2.0 covers Markets fully. Vintage themes need manual Liquid edits to expose switchers.
B2B on Plus
(company accounts, catalogs)
Horizon and Dawn ship B2B blocks: customer login, company switcher, quick-order, draft-order checkout. Renders B2B-specific pricing when buyer is a company contact.For complex B2B workflows beyond native — see the B2B on Plus guide for the five real gaps.
Hydrogen
(headless)
A separate framework, not a layer on OS 2.0. Replaces the theme entirely with a custom React frontend hitting the Storefront API.Pick Hydrogen only when: a non-Shopify CMS owns content, one frontend serves multiple backends, or design exceeds Liquid sections.

The pattern across all three is the same: OS 2.0 handles the storefront, and the bigger Shopify capabilities sit cleanly on top of it. Markets and B2B on a current OS 2.0 theme need zero theme code — they just work. Hydrogen is the one place where OS 2.0 stops, and the gap is narrower in 2026 than it was in 2021. If you're scoping a re-platforming project, default to OS 2.0 and let the headless decision be a separate, evidence-driven conversation.

The 80/20 rule for storefront choice
For roughly 80% of merchants — including most six- and seven-figure brands — OS 2.0 on a free or premium theme is the right answer. The 20% that benefit from headless are typically content-heavy brands with full-time engineering teams. Default to OS 2.0; promote to headless only when the business case is concrete, not aspirational.

The Bottom Line

OS 2.0 is no longer the new thing — it is the baseline. The decision in front of most merchants is not "should I use OS 2.0?" but "am I still on a Vintage theme, and if so, what is the cost of moving versus the cost of staying?" That answer is rarely emotional; it comes from the diagnostic in section 6 and the cost table in section 9.

Default to OS 2.0; migrate when value, not deadline, drives it. New stores in 2026 should launch on an OS 2.0 theme — Horizon by default, Dawn for conservative builds, premium themes when design dictates. Existing Vintage stores should plan a migration window when the friction list (recurring developer asks, missing app blocks, unmaintained theme) crosses the cost line — not because OS 2.0 is mandatory, but because every month the gap widens.
Your Next Step by Stage
Launching a new storeStart on Horizon. It is free, OS 2.0 to the core, and the editor surface you'll be using for the next several years.Browse Horizon
Running a Vintage themeRun the diagnostic in section 6 against your current build. If three or more recurring asks turn into editor-only work on OS 2.0, schedule the migration.What is a Shopify theme
Need a developerCustom OS 2.0 themes pay back fastest when reused sections cut future merchant-team work. Hire for that outcome, not for a one-off site.Hire a Shopify developer

Read the official Online Store 2.0 documentation

Shopify's developer docs are the authoritative reference for JSON templates, sections, theme app extensions, and the rest of the OS 2.0 surface. Confirm specifics against the official source before scoping a build.

Open OS 2.0 docs

Frequently Asked Questions

Online Store 2.0 is the architectural overhaul Shopify shipped in 2021 to its theme layer. It introduces JSON templates, sections on every page, app blocks via theme app extensions, and tighter metafield integration. The practical effect: merchants edit any page in the theme editor, and apps install UI as blocks instead of editing theme code.
There is no Shopify product called 'Shopify 2.0'. The 2.0 label refers strictly to the Online Store sales channel — the theme architecture. Confusion is common because Shopify ships major updates twice a year through Editions, but those are separate from the OS 2.0 baseline introduced in 2021 and still in use today.
No. Vintage (non-OS-2.0) themes still work and Shopify has not announced a deprecation date. However, every theme in the Shopify Theme Store is now OS 2.0, all new free themes ship as OS 2.0, and most new platform features (app blocks, section groups, AI editor surfaces in Horizon) require an OS 2.0 theme to use.
A section is a page-level building block such as a hero, product grid or featured collection. A block is a smaller unit nested inside a section, such as a single testimonial inside a testimonials section or a single review inside a reviews block. OS 2.0 made blocks app-installable through theme app extensions.
For merchants, JSON templates are significantly easier — they are edited entirely through the visual theme editor with no code. For developers, JSON templates are simple lists of sections and settings; the complex rendering still lives in the section's Liquid file. The split improves both merchant usability and developer maintainability.
Horizon is Shopify's current flagship and the default recommendation for new stores. Pick Dawn when the team needs a more conservative, longer-running reference theme with extensive community documentation. Both are free, both are OS 2.0, both are maintained by Shopify — the gap is more about editor surface and AI-assisted blocks than core architecture.
No. OS 2.0 governs storefront pages only. Checkout customisation runs on a separate framework called checkout extensibility. App-installed checkout UI extensions work on every Shopify plan, but the deeper customisations — replacing checkout.liquid, shipping custom checkout apps, sandbox environments — are restricted to Shopify Plus. None of it lives in the OS 2.0 theme editor.
Migration itself is SEO-neutral when done correctly: URLs, redirects, structured data, meta tags and page titles all carry over. SEO regressions usually come from secondary issues — slower page speed from over-stacked app blocks, JSON-LD lost during template rebuilds, or accidental noindex flags. Audit Lighthouse and a Screaming Frog crawl before publishing.
Most layout, content and merchandising changes are now in the theme editor — drag, drop, edit settings. You need a developer when you want a new section type that does not exist, bespoke layout logic, custom integrations, or complex performance work. The DIY ceiling on OS 2.0 themes sits noticeably higher than on Vintage themes.
For most merchants, yes — OS 2.0 closes the customisation gap that previously pushed brands toward headless. Pick Hydrogen or another headless framework only when you genuinely need multi-source content, full design control beyond Liquid sections, or to share a backend across multiple custom frontends. Otherwise OS 2.0 ships faster at a fraction of the cost.
About This Article
Shopify Developer & E-Commerce Writer
9+ years with Shopify since 2017

Front-end developer specializing in Shopify since 2017. Experienced in building custom Liquid themes, optimizing storefront performance, and integrating third-party apps. Writes in-depth, data-driven e-commerce guides based on hands-on experience with real merchant stores.

Continue Learning

What to Read Next

Stay updated

Get notified about new articles

Subscribe to receive updates when we publish new Shopify guides and insights.