If you’ve searched for this topic, there’s a decent chance you landed here after reading a Shopify Community thread full of merchants venting about losing checkout.liquid. It’s one of the more consistent frustrations in the Community forums, store owners who spent years fine-tuning a custom checkout page with Liquid, only to be told that flexibility is being retired in favour of something called “checkout extensibility.”
The frustration is understandable. Checkout.liquid let developers touch almost anything, layout, custom scripts, bespoke upsell logic, conditional field behaviour, directly in the checkout template. Checkout extensibility replaces that with a structured system of extension points, UI components and Shopify Functions, and it genuinely does close off some things that used to be possible.
But “more restricted” isn’t the same as “not customisable.” Checkout extensibility can do a lot that checkout.liquid never could, safer upgrades, faster checkout performance, and programmatic logic that would have needed fragile custom scripting before. This post lays out, plainly, what you can and can’t do with Shopify checkout in 2026, so you can plan a rebuild instead of guessing at what’s still achievable.
Why Checkout.liquid Is Gone
Checkout.liquid was Shopify’s original way of letting merchants and developers edit the checkout page directly with Liquid templates and custom code. It worked, but it came with real costs for Shopify: every custom checkout.liquid implementation had to be manually re-tested against every platform update, which slowed down how fast Shopify could ship checkout improvements (new payment methods, accessibility fixes, performance upgrades, fraud protection changes) across the entire merchant base.
Shopify’s response was checkout extensibility, a model where merchants customise checkout through defined extension points and Shopify Functions instead of freeform code. The trade-off is explicit: Shopify controls the checkout’s core structure and security, and you customise within a defined set of “slots” using its extension framework. Checkout.liquid customisation has now been fully retired across Shopify stores, and any store still relying on legacy checkout scripts or checkout.liquid templates needs to have migrated to extensibility to keep making changes to checkout.
That’s the part worth sitting with before getting frustrated at the limitations: this isn’t a temporary state you’re waiting out. Checkout extensibility is the checkout architecture going forward, so the practical question is what you can still achieve within it.
How Checkout Extensibility Actually Works
Checkout extensibility is built from two distinct tools, and understanding the difference matters because they solve different problems.
UI Extensions: The Visual Layer
UI extensions let you add, remove or modify visual elements at specific points in checkout, Shopify calls these “extension points” (for example, above the order summary, below the shipping method selector, or on the Thank You and Order Status pages). You build these with Shopify’s checkout UI extension framework (React-like components rendered through Shopify’s own UI toolkit), not raw HTML/CSS/JS, which is a deliberate constraint to keep checkout accessible, fast and secure.
With UI extensions you can realistically:
- Add custom fields for the buyer to fill in (gift messages, delivery instructions, ID or licence numbers for regulated products)
- Show dynamic banners or messages (delivery estimates, loyalty point balances, low-stock warnings)
- Add upsell or cross-sell offers at checkout using Shopify’s post-purchase and in-checkout offer extension points
- Adjust checkout branding, logo, colours, fonts, corner radius, and general visual styling through the checkout branding editor in Shopify admin
- Rearrange and configure which native blocks appear where, if you’re on Shopify Plus, using the drag-and-drop checkout editor
Shopify Functions: The Logic Layer
Shopify Functions are small, sandboxed pieces of backend logic that plug into specific checkout behaviours without touching the UI. They run fast, server-side, and are what replaced the old checkout.liquid scripts and (before that) Shopify Scripts for merchants who’d used those. Functions currently cover things like:
- Discount functions, custom discount logic beyond what Shopify’s native discount engine supports out of the box (tiered logic, bundle-based discounts, customer-segment-specific rules)
- Validation functions, blocking checkout completion based on custom business rules (minimum order quantities per product, restricted shipping combinations, custom payment eligibility)
- Delivery customisation functions, reordering, renaming, or hiding shipping rates based on cart contents or customer attributes
- Payment customisation functions, hiding or reordering payment methods based on cart value, currency, or customer type
Functions are written in languages that compile to WebAssembly (commonly Rust or JavaScript via Shopify’s tooling) and are deployed as part of a Shopify app, even a private one built just for your store. This is a meaningfully more technical undertaking than the old checkout.liquid editing, which is the trade-off most merchants are actually reacting to in those Community threads: it’s not that customisation disappeared, it’s that it now requires developer tooling rather than editing a template file.
What You Can Actually Do With Checkout Extensibility Right Now
Here’s a practical checklist of what’s realistically achievable in 2026, assuming the right plan and development resource:
- [ ] Custom checkout branding (logo, colours, typography, button styling) via the native branding editor, available on all Shopify plans
- [ ] Custom fields and buyer prompts (gift notes, delivery instructions, terms acceptance checkboxes) via UI extensions
- [ ] Dynamic content blocks (trust badges, delivery estimates, loyalty messaging) at defined extension points
- [ ] Checkout and post-purchase upsells through supported extension points
- [ ] Custom discount logic beyond native discount codes, via discount Functions
- [ ] Custom shipping rate naming, reordering or hiding, via delivery customisation Functions
- [ ] Custom payment method visibility rules, via payment customisation Functions
- [ ] Order validation rules that block checkout completion for specific cart conditions, via validation Functions
- [ ] Full drag-and-drop rearrangement of checkout sections and app blocks, Shopify Plus only
What You Genuinely Can’t Do Anymore
This is where the Community frustration is fair, and where it’s worth being upfront rather than glossing over the gap:
- No freeform HTML/CSS/JS injection into the checkout page. Everything runs through Shopify’s extension components, which limits pixel-level layout control compared to checkout.liquid.
- No arbitrary third-party scripts loaded directly into checkout the way many merchants used to add tracking pixels, chat widgets, or custom UI libraries. Tracking is now handled through Shopify’s supported pixel and analytics APIs instead.
- No fully custom checkout page layout. You’re customising within Shopify’s defined checkout flow (contact, shipping, payment, review), not rebuilding the page structure from scratch.
- No editing checkout on the Basic or Shopify plan the way Plus merchants can. The full checkout editor with drag-and-drop app blocks is a Shopify Plus capability; non-Plus merchants get the branding editor and can still install extensions built by apps, but have less structural control.
- No instant, no-code changes for complex logic. Anything beyond branding and basic UI extensions genuinely needs a developer to build and deploy a Function or extension, this isn’t something a store manager can do from the theme editor in an afternoon the way checkout.liquid edits sometimes were.
Checkout Extensibility on Plus vs Standard Shopify
It’s worth being clear that the ceiling here isn’t the same for every merchant. Shopify Plus stores get the full checkout editor, meaning app blocks and custom extensions can be dragged into position across the checkout flow, and Plus merchants have historically had earlier and broader access to the more advanced Function APIs (payment and delivery customisation in particular). Non-Plus merchants can still install apps that use checkout UI extensions and some Function types, but building bespoke Functions for your own store specifically is, in practice, a project best suited to a Plus setup with dedicated developer support behind it.
If your store is weighing up whether that level of investment makes sense, is Shopify Plus worth it is worth reading before committing, since checkout customisation is only one factor in that decision.
When to Bring In a Specialist
Building a custom Shopify Function is not the same undertaking as editing a Liquid template used to be. It involves setting up a Shopify app (even if it’s private and used only by your store), writing and testing logic in a supported language, and deploying it through Shopify CLI, plus ongoing maintenance as Shopify’s Function APIs evolve. In our experience, most merchants underestimate this the first time they scope it, because “customise checkout” sounds like a small ask compared to what it now actually involves technically.
This is exactly the kind of work where Shopify Plus development support earns its keep, scoping what’s genuinely achievable with extensions and Functions for your specific checkout requirements, building it correctly against Shopify’s current APIs, and avoiding a rebuild six months later because the first attempt was patched together without understanding the extension point constraints.
Realistic Timeframes and Effort
As a general guide, a straightforward checkout customisation, a couple of UI extensions plus one Function, such as a custom field and a delivery customisation rule, typically takes a few weeks from scoping to deployment, including Shopify’s app review process for anything distributed beyond your own store. More involved projects, like multiple interdependent Functions handling discount logic and payment method rules together, tend to run longer, simply because each Function needs its own testing against real cart and customer scenarios before it goes live on a checkout that’s processing real orders.
FAQ
Is checkout.liquid completely retired now, or can I still use it on an older store?
Checkout.liquid customisation has been fully deprecated across Shopify stores. Stores that hadn’t migrated by Shopify’s enforced cutover are now on the standard, non-customised checkout until they rebuild their customisations using checkout extensibility, there’s no way to opt back into checkout.liquid editing.
Can I still add tracking pixels and marketing scripts to checkout?
Yes, but through Shopify’s supported customer events and pixel APIs rather than by pasting scripts directly into the checkout page. Most major analytics and ad platforms have documented, supported ways to integrate through this system, so it’s usually a configuration task rather than a custom build.
Do I need Shopify Plus to customise checkout at all?
No, branding customisation and installing apps that use checkout UI extensions are available on all Shopify plans. What requires Plus is the full drag-and-drop checkout editor for rearranging app blocks and sections, and broader access to some of the more advanced Function types.
Will my old checkout.liquid customisations be automatically converted to extensions?
No, there’s no automatic conversion. Anything you had built in checkout.liquid needs to be re-evaluated and, where still needed, rebuilt as a UI extension or Function using current Shopify tooling and APIs.
How much of my previous checkout customisation will I actually get back?
It depends what it was doing. Branding, custom fields, upsells, discount logic, shipping and payment rules are all realistically achievable again through extensions and Functions. Freeform layout changes, arbitrary third-party scripts, and fully custom page structures generally aren’t, that’s the genuine, permanent gap compared to checkout.liquid.
Ready to Rebuild Your Checkout Properly?
If your checkout customisations broke, disappeared, or never made the jump to extensibility, it’s worth getting a clear scope of what’s actually achievable for your specific requirements before committing developer time to a rebuild. Book a call with Nexly and we’ll walk through what your checkout can realistically do under the current Shopify extensibility model.
