Shopify’s checkout is not part of your theme, and hasn’t been for more than two years. checkout.liquid stopped rendering the Information, Shipping and Payment steps on 13 August 2024. On the Thank you and Order status pages it survived a year longer: checkout.liquid and additional scripts were sunset there on 28 August 2025, and app script tags stopped running on those pages on the same date for Plus stores and on 26 August 2026 for everyone else. Shopify Scripts is on the same path: not editable since 15 April 2026, not executing after 30 June 2026.
What replaced all of it is narrower on purpose, and the narrowness is the part worth understanding.
The failure mode checkout.liquid actually had
checkout.liquid was a copy of Shopify’s checkout, frozen at the moment you edited it. Every change Shopify made afterwards — a new payment method, the one-page layout, an accessibility fix — had to be re-merged into that copy by hand, or was silently missed. Nothing failed loudly. The store kept taking orders while its checkout drifted further from the one Shopify was actually maintaining.
That is what “breaking the next update” means here. Not a build error. A conversion surface that stopped tracking the platform and nobody noticed.
Checkout Extensibility (now called Shopify Extensions in Checkout) inverts the relationship. You no longer own the page. You declare what you want to render and roughly where, and Shopify renders it inside whatever checkout has become this quarter.
What UI extensions can and cannot do
Checkout UI extensions run in a Web Worker, isolated from the checkout page and from every other extension. There is no window, no DOM, no access to the checkout’s own HTML or assets, and no access to payment data. You render components Shopify provides — web components built on remote-dom, Shopify’s cross-platform UI library — and Shopify draws them into the page on your behalf.
Placement comes in three flavours. Block targets go wherever the merchant drags them in the checkout editor. Static targets are pinned: after the contact fields, before the pay button, under a cart line. Runnable targets render nothing at all — they respond to events and supply data.
Two constraints shape what you can build. UI extensions on the Information, Shipping and Payment steps require a Shopify Plus plan; the Thank you and Order status pages are open more widely. And calling anything outside Shopify requires declaring network_access in the extension’s TOML, which for a public app is a review conversation rather than a config flip.
What Functions can and cannot do
Shopify Functions are the other half, and they are where business rules belong. A Function is a WebAssembly module — Rust or JavaScript, with Rust recommended for carts large enough to matter — that Shopify executes on its own infrastructure at the moment a decision gets made. It receives JSON derived from a GraphQL input query you write, and returns JSON describing operations for Shopify to apply.
The Function APIs cover discounts, cart transform, delivery customization, payment customization, cart and checkout validation, order routing, fulfillment constraints, and the pickup option generators. Broadly: anything that used to be a Ruby script, plus a good deal that never was.
The limits are real and worth knowing before you design around them. An input query is capped at 3000 bytes and its calculated cost at 30, the resulting input JSON at 128 kB for carts up to 200 lines (scaling up for larger carts), list arguments at 100 elements; metafield values over 10 kB aren’t returned at all. And a Function generally cannot phone home — a fetch target exists, but it is restricted to custom apps on Enterprise stores. For everyone else, a Function decides using exactly what the input query handed it, and nothing else.
On plans: any store can install a public app containing Functions, but a custom app containing Function APIs requires Plus.
What you actually give up
Arbitrary CSS. Branding runs through checkoutBrandingUpsert — a Plus-only API — against a checkout profile: a design system of colours, typography and corner radius, plus per-component customisations for the header, buttons, form fields and sections. That is a vocabulary, not a stylesheet. When a brand guideline falls outside it, the answer is no, and it is better to say so during design than during implementation.
Arbitrary JavaScript. No third-party tag on the checkout page, no A/B tool that rewrites the DOM, no vendor snippet that “just needs to go in the head”. Customer events run in their own sandbox and observe; they do not edit the page.
Layout and step order. You cannot add a step, remove one, or reorder them. You fill slots Shopify defines, and the merchant decides in the checkout editor which of those slots you get.
A stable API surface forever. Extensions declare an API version, and versions move. Checkout metafields were removed from checkout UI extensions in the 2026-04 version and replaced by cart metafields — a genuine migration with genuine work attached. And 2025-07 was the last version to support React-based UI components: extensions still on it must move to Polaris web components or can no longer be updated after 1 October 2026.
That last one is also the clearest illustration of why the model holds up. The change was announced, dated, documented, and given a replacement, and each stable API version is supported for at least twelve months with at least nine months of overlap between consecutive versions. Breakage becomes something you schedule, not something that arrives with a deploy you were never told about.
Why the constraint is the point
Checkout is the most locked-down surface on Shopify for the same reason it is the most valuable: it handles money and card data, and it changes constantly. The sandbox that denies you the DOM is precisely what makes it defensible to run third-party code on a PCI-relevant page at all. The fixed set of slots is what lets Shopify redesign checkout without negotiating with every app author first.
The trade is expressiveness now in exchange for the platform’s future work for free. Stores on checkout.liquid took the other side of that trade and paid twice — once to build it, once when it stopped rendering.
Where to put logic so it survives
Pricing decisions go in Functions, not on the cart page. A discount computed in Liquid or in theme JavaScript is a label. Checkout recalculates from Shopify’s own state, and only Functions participate in that calculation. If the cart page number comes from theme code and the checkout number comes from somewhere else, you have two sources of truth and one of them will drift.
Custom data goes in metafields, not hidden line item properties. The _ prefix on a line item property is a naming convention that keeps a value out of customer-facing displays. It is not a type, not a validation, not an access control, and not privacy — the value still travels with the line into the order and into merchant-facing views. It also fragments the cart, because two identical variants carrying different properties become two separate lines, which quietly changes quantity handling and merge behaviour. Metafields have definitions and types, live in a namespace, can be reserved to a single app with the $app: prefix, are readable from a Function’s input query, and are readable and writable from a UI extension through the Metafields API. Order metafield definitions can also copy their value from a cart metafield automatically at order creation, which removes the usual reason for reaching for line item properties in the first place.
Function configuration goes in metafields too. Read thresholds, rules and merchant-set options through the input query instead of compiling them into the Wasm module. The behaviour then changes without a redeploy — and without you.
Theme code stays on the storefront. Product page, collection, cart. The moment theme code starts assuming a shape for checkout — a selector, a step order, a script expecting to run after payment — it depends on something you neither control nor get warned about.
Anything genuinely bespoke goes in an app. A Function, a UI extension and an admin surface, versioned and deployed as a unit, is upgradeable in a way a snippet pasted into a theme file two years ago is not.
Checkout Extensibility cannot do everything checkout.liquid could, and it was never going to. What it does instead is make the things it can do survive the next release, and put the things it can’t in writing, in advance, with a date attached. On the one page in the store that takes money, that is the better arrangement.