The decision belongs upstream of cutover: identify which checkout customizations survive on Shopify Plus via checkout extensibility, which retire as part of the migration, and which require workflow changes elsewhere in the order pipeline. Brands that defer this decision into build phase consistently end up replicating source-platform logic in places it does not belong (theme code, post-purchase scripts, OMS workflows).
This page is the operator playbook: how to inventory the checkout customizations, what Shopify Plus actually supports, and how to make the retirement decisions that simplify the post-migration architecture.
Symptoms
How the problem surfaces
Custom checkout fields stop appearing at the right step
Source-platform required fields (delivery instructions, gift messages, business-account references) either disappear entirely or appear in awkward places in the new Shopify checkout. Customers either miss them or are forced to enter them in unexpected locations.
Discount logic produces different totals
Custom discount calculations (stack-vs-no-stack, line-item rules, tier-based pricing) do not transfer cleanly. Customer order totals come out differently than expected, generating support tickets and refund disputes.
Payment routing breaks for specific scenarios
Source-platform rules routing certain orders to specific payment processors (B2B to ACH, high-risk to manual review, international to alternative gateway) often need re-implementation via Shopify Functions or Apps. Missing this work causes payment authorisation failures.
Theme code grows to compensate for missing checkout features
The slow-burn failure mode. Engineers reimplement source-platform checkout logic in theme code because Shopify checkout cannot support it natively. The theme grows, breaks during future updates, and accumulates maintenance debt.
Solution
The operator playbook
Inventory checkout customizations during discovery
During discovery, build an explicit inventory of every customization in the source-platform checkout: custom fields with their data destinations, business rules with their trigger conditions, discount logic with edge cases, payment routing rules, post-purchase flows. Most of this lives in source-platform configuration that is invisible until inventoried.
The inventory exercise almost always surfaces customizations the operations team had forgotten about — fields added years ago for a one-off integration, rules that handle specific customer segments. Surface these in discovery; the cost of forgetting them is post-launch incidents during specific scenarios that nobody catches until customers complain.
Map customizations to Shopify Plus checkout extensibility
For each inventoried customization, decide whether it can be reproduced via Shopify Plus checkout extensibility (UI extensions, Shopify Functions for discounts and shipping, custom validation), reproduced via apps from the Shopify App Store, or must be retired as part of the migration. The decision belongs in discovery, before build phase.
Checkout extensibility covers more than it did even two years ago, but not everything. Custom field collection, custom validation, custom shipping methods, and discount logic are well-supported. Truly arbitrary payment routing, complex multi-step custom flows, and inline custom UI beyond extension points are still hard. Be honest about what extensibility supports; do not over-promise based on what extensibility might support in the future.
Retire the customizations that simplification favours
The migration is an opportunity to simplify the checkout. Many source-platform customizations were responses to constraints that no longer exist on Shopify, or solutions to problems that have better-supported alternatives now. Identify the customizations whose retirement actually improves the checkout experience; brands often discover that simpler checkouts produce better conversion rates.
Communicate the retirement decisions to internal stakeholders early. Customer service, finance, and operations teams sometimes depend on specific checkout fields for downstream workflows. Retiring those fields without updating the downstream workflows produces operational friction that exceeds the simplification benefit.
Test the checkout end-to-end before cutover
Before cutover, run end-to-end checkout testing for every customer scenario the brand serves: B2B, B2C, gift orders, international, subscription, wholesale, exempt customer, high-value, low-value, multi-discount stack. Each scenario can fail differently; testing each one specifically catches the issues that single-scenario testing misses.
The testing pass is operationally simple but easy to compress when timeline pressure builds. Brands that compress checkout testing consistently surface customer-facing checkout incidents post-launch; brands that protect the testing window catch the issues in staging where they belong.
Cost
Cost range: $15K-$80K (inside the broader replatforming engagement)
| Cost line | Range |
|---|---|
| Checkout customization inventory | $3K-$10K |
| Extensibility / app mapping decisions | $2K-$8K |
| Shopify Functions or Apps development | $5K-$40K |
| Payment routing reconfiguration | $2K-$10K |
| End-to-end scenario testing | $3K-$12K |
Cost scales with the complexity of the source checkout customization. Brands with simple checkout (B2C only, no custom fields, standard discount logic) land at the lower end. Brands with heavy B2B, custom fields throughout, and complex discount stacks consistently land near the upper bound. Above $50K, the brand should consider whether the customizations are genuinely needed.
Timeline
Timeline: 6-12 weeks (parallel to broader replatforming)
Inventory
Weeks 1-3
Source checkout audit, customization documentation, downstream dependency mapping
Mapping decisions
Weeks 3-5
Per-customization decision: extensibility, app, retire
Implementation
Weeks 5-10
Shopify Functions development, app configuration, payment routing setup
Testing
Weeks 9-11
End-to-end scenario testing, edge-case validation, regression checks
Cutover monitoring
Weeks 11-14
Post-launch checkout monitoring, incident response, fix iteration