June 27, 2026

Checkout Customisation on Shopify Plus

How to scope checkout customisation work for a Shopify Plus brand in 2026: what Checkout Extensibility allows, the migration mandate, cost and timeline framework.
7 min read
Flux Insights Static Hero
Adam Tregear
Founder @ Flux

Shopify Plus checkout customisation now uses Checkout Extensibility: supported extensions, Functions and branding tools rather than edits to checkout.liquid. The practical question is what your checkout needs to do for customers, and which supported tool can do it.

This guide covers the options, limits, existing-customisation audit, cost and timeline framework. Our team plans the buying experience and reviews the work; AI helps delivery move faster, while people stay responsible for the release.

What changed in 2024

Shopify ended checkout.liquid support for the information, shipping and payment steps in August 2024. The Thank you and Order status sunset followed on 28 August 2025. Existing requirements now need supported replacements rather than more edits to the old template.

The change wasn't a refactor. It was an architectural shift. checkout.liquid let agencies modify the checkout template like any other Liquid template. Extensions don't work that way. They're isolated components that plug into specific extension points Shopify defines. Functions run server-side on Shopify's infrastructure, with strict capability boundaries. The customisation model is more structured, more performant, more secure, and meaningfully different from what brands and agencies built over the checkout.liquid years.

Start by checking what is live. A saved checkout.liquid customisation is not proof that the field, promotion or tracking still works. Map each requirement to an extension, Function, branding setting or supported app, then test the complete journey.

What you can actually customise

Five categories cover most brand requirements.

UI extensions at checkout

Visual customisations to the checkout flow. Custom fields (gift messages, delivery instructions, order purpose, B2B PO numbers). Custom UI elements (banners, social proof, urgency messaging, trust badges). Conditional content (different messaging for first-time vs returning customers, B2B vs DTC, region-specific compliance). Dynamic shipping option presentation. The extension targets cover most surfaces brands actually want to touch.

Functions for business logic

Choose the Function for the rule: discounts for savings, validation for minimum-order checks, Cart Transform for supported bundle and line operations, Delivery Customization for available delivery options, and Payment Customization for payment-method rules. Automatically adding a free gift needs its own supported cart or app flow; it is not a blanket Cart Transform capability.

Post-purchase pages

Post-purchase offers appear after payment and before the Thank you page where the order is eligible. They are distinct from Thank you and Order status extensions used for follow-up content. Surveys, subscription changes and delivery preferences need the right app and supported surface. Check payment-method, currency and other offer limitations before scoping the experience.

Custom Pixels

Custom pixels collect customer events in a client-side sandbox. They are not server-side tracking by themselves. Choose supported app pixels where suitable, respect consent, and test event delivery and deduplication with any separate server-side integration.

Branding and theme customisation

Visual styling of the checkout itself. Colours, fonts, layout, sectioning, logo placement. More flexible than checkout.liquid in some ways, more constrained in others. Most brands can achieve their target visual identity within the branding API limits.

What you can't customise

Worth knowing where the boundaries sit.

The core checkout flow. The sequence of information capture (contact, shipping, payment) is owned by Shopify. Brands can add fields and content but can't reorder the fundamental flow or merge steps in unconventional ways.

Payment processing. The payment capture, fraud detection, and transaction routing run on Shopify's payment infrastructure. Brands customise around payment but don't replace the payment system.

Address validation and shipping rate calculation. The underlying logic stays with Shopify and the carrier integrations. Custom shipping rules can layer on top but can't replace the core address and rate logic.

The checkout URL structure. The checkout runs on a Shopify-hosted URL. Brands customise the branding, the URL pattern stays Shopify-owned.

For most brands, the constraints don't block actual requirements. The brands that hit constraints are usually trying to rebuild things that Shopify intentionally owns for security, compliance, or reliability reasons.

The migration mandate

For a store with older customisations, audit three areas before planning new work.

Existing requirements. Record each old field, message, rule and integration, then confirm whether it works in the current checkout. The work is meaningful but bounded: our existing estimate for migrations is 6-14 weeks, depending on complexity.

Supported replacements. Decide what belongs in a checkout extension, a Function, branding settings or a compatible app. Some old behaviour should be simplified rather than recreated.

Customer and operations testing. Check payment methods, shipping, tax, order data, tracking and any B2B flow. A visual match does not prove the whole checkout works.

Build new work on supported surfaces. Use the audit to separate missing essentials from changes that would make buying clearer or easier.

Common customisation patterns we ship

The work that comes up repeatedly across mid-market Plus engagements.

Custom checkout fields with conditional logic. Gift message fields that appear only when a gift option is selected. PO number fields that appear only for B2B customers. Delivery instruction fields that vary by shipping method.

Trust-building modules at checkout. Social proof banners (real-time order count, customer photos), security badges, return policy reminders, contact information. The extension targets allow tasteful placement that improves conversion without cluttering the experience.

Dynamic shipping option presentation. Showing estimated delivery dates instead of generic shipping speed labels. Highlighting the cheapest or fastest option dynamically. Adding shipping cost transparency (origin, carrier, service level).

Post-purchase upsells with native acceptance. Single-click offers for eligible orders, with a fallback when the offer cannot appear. High conversion rates - 10-15% of orders typically accept well-designed post-purchase offers.

B2B-specific checkout customisations. Different field layouts for B2B accounts. Custom payment terms surface. PO/quote integration. Approval workflow integration where required.

Customer-event tracking. Configure and test app or custom pixels, consent behaviour and duplicate-event handling. Scope a separate server-side integration where the measurement plan needs one.

Cost and timeline framework

For typical mid-market Plus brands scoping checkout customisation work.

Simple scope (custom fields + post-purchase page): $15K-$30K, 4-6 weeks. Single extension, straightforward post-purchase upsell, basic testing.

Standard scope (multi-extension + Functions + post-purchase): $30K-$60K, 6-10 weeks. Multiple extensions, custom Functions for business logic, post-purchase optimisation, B2B handling if applicable.

Complex scope (full migration + new customisations): $50K-$120K, 10-16 weeks. Full migration from checkout.liquid, multiple new customisations, complex business logic, multi-region handling, extensive testing.

Headless add-on: $10K-$30K, 2-4 additional weeks. Integration work on the Hydrogen side where the storefront hands off to checkout.

Ongoing optimisation retainer: $5K-$15K/month for continuous testing and feature additions post-launch.

The cost gap from simple to complex isn't arbitrary - the testing surface grows non-linearly. Every conditional path, every business rule, every edge case needs verification across payment methods, customer types, regions, and integration touchpoints.

Where most projects underscope the work

Four patterns from checkout projects we've shipped or audited.

Underscoping the migration audit. Brands assume their checkout.liquid customisations will map 1:1 to Extensions. Some do, some don't. The audit is what surfaces which is which. Skipping it produces mid-project scope changes that cost more than the audit would have.

Treating extensions as a UI exercise rather than a system change. The Functions side is where most strategic value sits. Brands that focus only on visual customisations miss the bigger lift from Functions-based business logic.

Skipping post-purchase pages. One of the highest-ROI surfaces in the new system. Brands that deploy with the default thank-you page leave meaningful upsell revenue on the table. Building post-purchase customisations should be part of any checkout project, not a phase-two addition.

Underestimating testing time. Checkout testing requires real transaction scenarios across payment methods, customer types, regions, and integration touchpoints. The testing phase routinely surfaces edge cases that need fixing. Brands that compress testing to save time ship checkout regressions to production.

Where to start

If you're scoping checkout customisation work for a Shopify Plus brand, four moves order the work.

One: audit your current checkout. What customisations exist today, what platform they're built on, what business logic they encode. The audit is the foundation for everything that follows.

Two: map your customisation goals. What you actually want the new checkout to do. Specific outcomes, not vague "better checkout" framing. Conversion lift, AOV lift, B2B support, multi-region handling, tracking accuracy.

Three: scope fixes to older customisations alongside new work. Confirm which requirements are missing before deciding what to replace, simplify or retire.

Four: budget for ongoing optimisation. Checkout isn't ship-and-forget. The strongest brands run continuous testing on checkout flows, post-purchase offers, and conversion experiments.

Talk to our team about checkout customisation. We ship migrations, custom extensions, Functions-based business logic, and post-purchase optimisation across mid-market Plus brands. The discovery call takes 30 minutes and you'll leave it knowing what your specific scope and cost look like. Related reading: cart customisation on Shopify Plus and post-purchase upsell on Shopify Plus.

Is checkout.liquid still supported in 2026?

No. checkout.liquid is unsupported for the information, shipping and payment steps. The Thank you and Order status pages reached their sunset on 28 August 2025. Audit old requirements and replace them with supported extensions, Functions, branding tools or apps.

What can I actually customise on the new checkout?

UI extensions add supported fields and content. Functions handle the relevant discount, delivery, payment or validation rules. Eligible post-purchase offers and separate Thank you or Order status extensions serve different jobs. The combination covers 90%+ of what brands actually need; confirm the supported target and app for each requirement.

What can't I customise?

Shopify still owns the checkout shell - payment processing, address validation, the core checkout flow logic. Brands can't fully replace the checkout UI or run checkout entirely on their own infrastructure. The constraints are real but rarely block what brands actually need to ship.

How much does a checkout customisation project cost?

$15K-$80K for typical mid-market scope depending on complexity. Simple custom field additions and post-purchase pages: $15K-$30K. Multi-feature builds with conditional logic and B2B handling: $30K-$60K. Complex migrations from heavily-customised checkout.liquid: $50K-$120K. Headless implementations add $10K-$30K for the Hydrogen-side integration.

How long does it take?

4-10 weeks for typical mid-market scope. Discovery and audit 1-2 weeks, extension development 2-5 weeks, testing 1-2 weeks, go-live 1 week. Complex migrations or multi-feature builds extend to 12-16 weeks. The work doesn't compress well below 4 weeks because checkout testing requires real transaction scenarios across payment methods and edge cases.

Can I do this with my existing apps (ReConvert, AfterSell, Recharge)?

Yes for most apps. Major checkout-adjacent apps have updated their integrations to work with Checkout Extensibility. ReConvert, AfterSell, Recharge, Bold, and others have native Extensibility-compatible versions. The exception is brands running deeply-customised app implementations from the checkout.liquid era - those usually need rework alongside the platform migration.

What about headless brands on Hydrogen?

Hydrogen storefronts hand off to Shopify checkout (the storefront runs in Hydrogen, the checkout runs on Shopify). The Checkout Extensibility customisations work the same way - they apply to the Shopify-hosted checkout that Hydrogen routes to. Headless brands get the same customisation surface as theme-based brands, plus the option to build the pre-checkout experience (PDP, cart, etc.) fully custom.

Where do most brands go wrong?

Three patterns. Underscoping the migration audit - brands assume their checkout.liquid customisations will map cleanly to Extensions and discover edge cases mid-project. Treating extensions as a UI exercise rather than a system change - the Functions side is where most strategic value sits. Skipping post-purchase pages - one of the highest-ROI surfaces in the new system and most brands deploy with the default.

/score

Does AI recommend your brand?

We ask ChatGPT and Perplexity 10 real buying questions for your category and score you against your biggest competitor. Live, in about 2 minutes.

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.

Free. Enter your store's website, e.g. yourstore.com

Flux is a Shopify Plus Agency for Advanced Engineering & AEO

TLDR Summary
  • checkout.liquid is no longer supported. Audit old customisations against current checkout behaviour before adding new work.
  • Use supported UI extensions, Functions, branding tools and eligible post-purchase offers. Custom pixels collect events in a client-side sandbox.
  • What you can't customise: the core checkout flow sequence, payment processing, address validation, the checkout URL structure. The constraints are bounded and rarely block actual brand requirements.
  • Cost framework: $15K-$30K simple scope (custom fields + post-purchase). $30K-$60K standard (multi-extension + Functions). $50K-$120K complex (full migration + new customisations). Headless adds $10K-$30K.
  • Timeline: 4-10 weeks for typical scope, 10-16 weeks for complex migrations. Doesn't compress well below 4 weeks because checkout testing needs real transaction scenarios.
  • Most common pitfalls: underscoping the migration audit, treating extensions as UI-only, skipping post-purchase pages, underestimating testing time.