Shopify Checkout Extensibility Migration: What Breaks and What Doesn't
Shopify's checkout.liquid sunset forced every Plus merchant onto Checkout Extensibility. Here's what actually breaks during migration, what doesn't, and the patterns that held up for us in production.
The checkout.liquid sunset is no longer a future problem — if you're still running a customised legacy checkout on Shopify Plus in 2026, you're either paying for an extension or you've already lost your ability to edit it. We've migrated a handful of mid-size Plus stores onto Checkout Extensibility over the last 18 months, and the gap between "it compiled" and "it actually works in production" turned out to be wider than the Shopify docs suggest.
This is the honest field guide we wish we'd had on the first project.
What Checkout Extensibility actually is
Checkout Extensibility is Shopify's replacement surface for everything you used to hack into checkout.liquid. Instead of editing a Liquid template, you compose the checkout from:
- Checkout UI Extensions — React-like components (Preact under the hood) that render in specific extension points: above the summary, below shipping, on the Thank You page, etc.
- Shopify Functions — server-side logic in Rust or JS (compiled to WASM) for discounts, shipping method visibility, payment method visibility, and cart transforms.
- Branding API & Checkout Editor — the only sanctioned way to restyle. Theme CSS does nothing here.
- Web Pixels — the sandboxed replacement for
additionalScriptsand raw analytics injection.
The mental model shift is the hard part. You no longer own the page. You rent slots inside it.
Why this matters for engineering estimates
If a stakeholder shows you a Figma of the "new checkout," push back before you quote. Extensibility does not let you reposition native elements, change the column structure, or inject arbitrary markup between core sections. You can add, you can restyle within tokens, and you can validate — you cannot restructure. We've killed two proposals at discovery because the design was fundamentally incompatible with the platform.
What migrates cleanly
In our experience, roughly 60–70% of typical checkout.liquid customisations have a direct, lower-effort equivalent in Extensibility:
- Trust badges, shipping notices, delivery date estimates → UI extensions in
purchase.checkout.block.renderorpurchase.checkout.delivery-address.render-after. - Custom cart attributes and order notes → the
useApplyAttributeChangehook, cleaner than the Liquid version ever was. - Simple upsells on Thank You page →
purchase.thank-you.block.renderwith theuseOrderhook. - Discount stacking rules → Shopify Functions, which are genuinely a better architecture than the
Script Editorscripts they replace.
A minimal UI extension looks like this:
import {
reactExtension,
Banner,
useApi,
useApplyAttributeChange,
} from '@shopify/ui-extensions-react/checkout';
export default reactExtension(
'purchase.checkout.delivery-address.render-after',
() => <GiftNote />
);
function GiftNote() {
const { i18n } = useApi();
const applyAttributeChange = useApplyAttributeChange();
return (
<Banner title={i18n.translate('giftNote.title')}>
{/* input + onChange → applyAttributeChange({ type: 'updateAttribute', key: 'gift_note', value }) */}
</Banner>
);
}
Ship that, pin a version in shopify.extension.toml, and you have a production component. No build server, no CDN — Shopify hosts it.
What quietly breaks
This is the section we wish we'd written before project one.
Third-party scripts that assumed DOM access
Any vendor whose integration guide says "paste this snippet into additionalScripts" is now a Web Pixel or nothing. Pixels run in a sandboxed worker. They cannot read the DOM, cannot inject elements, and cannot block navigation. We've had to re-platform three loyalty widgets, one fraud tool, and a session-replay vendor that silently stopped recording checkouts for two weeks before anyone noticed.
Audit every script in your current checkout.liquid and order_status.liquid before the cutover. For each one, ask the vendor directly: do you have a Checkout UI Extension or a Web Pixel? If the answer is a roadmap date, you need a contingency.
Custom field validation
The pattern of "regex-validate a VAT number in Liquid and block checkout" is gone. Blocking is now done via the buyer-journey.intercept API, and it only runs at specific lifecycle points. Validation that used to feel instant now has to be designed around async checks and clear blocking states. Users notice.
const canBlockProgress = useExtensionCapability('block_progress');
useBuyerJourneyIntercept(({ canBlockProgress }) => {
if (canBlockProgress && !isValidVat(vat)) {
return {
behavior: 'block',
reason: 'Invalid VAT',
errors: [{ message: 'Please enter a valid EU VAT number.' }],
};
}
return { behavior: 'allow' };
});
Note the canBlockProgress capability check — on some checkout configurations you simply cannot block. Plan for the soft-fail case.
Analytics attribution
If your marketing team relies on GTM in checkout, the migration will cause an attribution gap. The Customer Events (Web Pixels) model fires standardised events, but the shape is different from what GTM dataLayer consumers expect. Budget time for your analytics engineer, not just your frontend engineer. We've seen reported conversion rates "drop" 8–12% post-migration purely from measurement drift.
Discount edge cases
Functions are great until you hit the input query size and execution-time limits. A Function that needs to iterate every line item against a large metafield-driven ruleset will fail silently at scale. Test with a cart that mirrors your 95th-percentile basket size, not your demo cart of two items.
The rollout pattern that worked for us
Four phases, roughly two weeks each on a mid-complexity Plus store:
- Inventory and triage. List every customisation in the legacy checkout. Classify each as keep, rebuild, drop. Get sign-off from marketing and finance before you write code — the "drop" column is where the political work lives.
- Rebuild in a development store. Use
shopify app devagainst a dev store with representative products, discounts, and shipping zones. Do not test against a blank store. - Shadow deploy. Checkout Extensibility can run alongside the legacy checkout for a window. Use the checkout profile system to route a small percentage of traffic to the new checkout and compare conversion, AOV, and error rates for at least a full week — ideally two, to cover a weekend cycle.
- Cut over, then monitor hard. Watch checkout completion rate, payment error rate, and ticket volume for 72 hours. Have the rollback plan written down, not in someone's head.
A note on the Checkout Editor
Merchandisers can move and configure your extension blocks from the Checkout Editor without telling you. This is a feature, not a bug — but it means your extensions must handle being placed in any valid extension point gracefully. Don't hardcode layout assumptions. Don't assume a block above you exists.
When to delay the migration
If you're on a legacy checkout that works, has low customisation, and your business isn't blocked by it — the honest answer is sometimes "wait a quarter." Shopify keeps adding extension points and APIs. Something that required a hacky workaround in early 2025 may have a first-class API now. Check the changelog before you scope.
That said, you cannot wait forever. Upgrades to one-page checkout, Shop Pay improvements, and new payment methods are only being rolled out on Extensibility. Every month you stay on the legacy stack, your conversion rate falls further behind the platform baseline.
Where we'd start
If you're staring at this migration on Monday morning: open your current checkout.liquid, order_status.liquid, and additionalScripts field, and write down every single customisation in a spreadsheet. For each row, note the business owner, the vendor (if any), and whether a native Extensibility equivalent exists today. That document — not the code — is the actual project plan.
If you want a second pair of eyes on the audit or the rollout plan, our team does this work regularly and we're happy to sanity-check scope. You can see what we do on our e-commerce services page or browse more checkout war stories on the blog.
Want a team like ours?
72Technologies builds production software for the kind of teams who actually read this blog.
Start a projectKeep reading
Why Your Shopify LCP Is Stuck at 3.2s (And the Six Fixes That Actually Moved It)
A field report on dragging Shopify product page LCP from the mid-3s into the low-2s. The usual advice doesn't cut it — here's what actually worked across three merchants in 2025.
WhatsApp Commerce in LATAM: What Actually Moves Revenue vs What Just Looks Good in Demos
We've shipped WhatsApp commerce flows for stores in Mexico, Colombia, and Brazil. Here's what actually converts, what the Meta sales deck won't tell you, and the integration patterns that survive contact with real customers.
Hydrogen vs Next.js for Shopify Headless: A Teardown After Three Builds
We've shipped the same storefront architecture on both Hydrogen and Next.js for Shopify clients. Here's where each one wins, where each one hurts, and the decision tree we now use before writing a single line of code.
