What Replaces Shopify Scripts (The Full Checkout Stack in 2026)

Shopify Scripts dies in 24 hours. The Plus team that has spent four years writing Ruby Scripts for cart logic, discounts, and shipping rules is about to inherit a completely different checkout stack. Four layers, three of them new since 2024. This is the full picture of what replaces Scripts and how the pieces fit together. Read this before July 1 if you want your developers to know what they are actually working with on Wednesday morning.

The 4 layers of the checkout stack in 2026

Shopify checkout in 2026 is not one thing. It is four layers stacked on top of each other, each with a different purpose and a different deployment model. The layers are:

• Shopify Functions. The business logic layer. WebAssembly modules that decide discounts, shipping rates, payment methods, and cart transformations.
• Checkout UI Extensions. The UI customization layer. React components that render inside checkout at defined extension points.
• Checkout Components. The custom UI primitive layer. Reusable building blocks for Plus merchants who want to build their own checkout interfaces.
• Shop Pay. The accelerated checkout and identity layer. One-tap checkout, saved payment methods, and the cross-store customer graph.

If you were used to Scripts, you were touching layer 1 only. The other three layers existed but were optional. After June 30 the optional becomes mandatory. Every Plus team needs working knowledge of all four.

Layer 1: Shopify Functions

Functions is the direct replacement for Scripts. The mental model shift is real. Scripts ran inline Ruby on Shopify's servers and modified cart objects in-flight. Functions are compiled WebAssembly modules that receive a defined input, return a defined output, and never touch the cart object directly.

What Functions can do today:

• Product discounts. Apply percentage or fixed amount discounts to specific products based on cart contents.
• Order discounts. Apply discounts to the entire order based on cart totals, customer tags, or product mixes.
• Shipping discounts. Apply discounts or free shipping rules based on cart conditions.
• Delivery customizations. Hide, rename, or re-sort shipping methods based on cart contents.
• Payment customizations. Hide, rename, or re-sort payment methods.
• Cart transformations. Bundle products, split line items, or apply custom pricing.
• Fulfillment constraints. Control which locations can fulfill which orders.

Each Function is a separate deployable artifact. You can have multiple Functions of the same type running at the same time. Shopify chains them together in a defined order. This is the biggest mental shift from Scripts: you no longer have one long Ruby file. You have a collection of small, focused Functions that compose.

If you are starting from zero, our Scripts to Functions migration playbook walks through the 4 paths to get there.

Layer 2: Checkout UI Extensions

Checkout UI Extensions are how you change what customers see in checkout. The mental model is: Shopify renders a default checkout, you inject React components at specific extension points to modify it.

Extension points include things like:

• cart-line-item for adding content next to each line item
• shipping-method for adding content near shipping methods
• order-summary for adding content in the order summary
• thank-you-block for adding content to the thank you page

What you typically build with Checkout UI Extensions:

• Custom upsell offers in checkout
• Gift message inputs
• Delivery date pickers
• Cart attribute editors (engraving, color, custom text)
• Trust badges and shipping promises
• Custom error messages for specific cart states

Checkout UI Extensions run on top of the standard Shopify checkout. They do not let you redesign the checkout from scratch. For that, you need Layer 3.

Layer 3: Checkout Components

Checkout Components went GA in Spring 26. This is the layer most Plus merchants do not yet understand. Components are reusable UI primitives that let you compose your own custom checkout interface.

The difference between UI Extensions and Components:

• UI Extensions add to the default checkout. You inject blocks into Shopify's layout.
• Components let you build your own checkout layout from scratch. You compose the entire experience using Shopify primitives.

Plus merchants use Components when they need full control over the checkout aesthetic and flow. Common reasons:

• Brand requires a specific layout that the default checkout cannot match
• Custom multi-step flow for complex products (configurable items, bundles, subscriptions)
• B2B checkout with negotiated pricing displays and credit terms
• Headless storefronts that need a checkout matched to the rest of the experience

Components is a Plus-only feature. The build cost is real. We typically scope custom checkouts at 3 to 8 weeks of agency time depending on complexity. The good news: once built, you control every pixel.

Layer 4: Shop Pay

Shop Pay is the layer that gets ignored in most checkout conversations because it is not something you build. It is something you turn on. But the impact on conversion is the largest of any single checkout decision.

What Shop Pay does in 2026:

• One-tap checkout for customers who have shopped at any Shop Pay store before
• Saved payment methods across the Shopify network (the Shop graph)
• Shop Pay Installments for buy-now-pay-later without a separate provider
• Customer identity that persists across stores
• Receipt and order tracking in the Shop app

The Shop Pay conversion lift on mobile is real. Shopify has reported Shop Pay completes checkout 4x faster than guest checkout. For BFCM 2026, having Shop Pay enabled and optimized is the single highest-ROI checkout decision a Plus merchant can make.

How the 4 layers fit together

A real customer checkout in 2026 touches all 4 layers in sequence:

Step 1: Customer adds items to cart. Functions run cart transformations and apply automatic product discounts.

Step 2: Customer hits checkout. Functions decide which discounts apply, which shipping methods to show, and which payment methods to surface.

Step 3: Checkout renders. If the merchant is using Components, the custom checkout layout loads. Otherwise the default Shopify checkout loads with any UI Extensions injected at extension points.

Step 4: Customer chooses payment. If Shop Pay is enabled and the customer has used it before, one-tap completes the purchase. Otherwise the standard payment flow runs.

Step 5: Order completes. Functions run on order creation for things like fulfillment routing. UI Extensions on the thank you page render any post-purchase content.

Every layer has a clear job. The mistake we see most often is teams trying to do something in the wrong layer. Business logic belongs in Functions. UI tweaks belong in UI Extensions. Custom layouts belong in Components. Payment optimization belongs in Shop Pay configuration.

What you can build with this stack that you could not build with Scripts

Scripts was limited to cart manipulation. The new stack opens up entire categories of customization that were impossible before.

Custom checkout for B2B. Negotiated pricing, credit terms, PO numbers, approval workflows. Components plus Functions plus customer metadata makes this possible without a separate B2B portal.

Subscription-aware checkout. Mixed cart of one-time and subscription items, with different discount logic for each. Cart transformations in Functions handle the math. UI Extensions show the customer what they are committing to.

Configurable products. Customer configures a product (engraving, color, custom assembly), and the cart shows the actual configuration with pricing. Cart transformations in Functions hold the configuration as metadata. UI Extensions let the customer edit it before checkout.

Loyalty integration. Real-time points balance, redemption, and tier-aware discounting all rendered inside checkout. UI Extensions show the customer their points. Functions decide the discount. The two communicate through cart attributes.

AI agent checkout. The new Cart MCP and Checkout Kit let AI agents (ChatGPT Operator, Claude, Gemini) complete checkout on behalf of customers. Functions still run, UI Extensions render in the agent context, Shop Pay handles identity.

What you cannot build with this stack

The new stack is more powerful than Scripts but it has limits. Things that remain impossible or difficult:

Modifying checkout step structure on Shopify. You can change what is in each step, but the core flow (information, shipping, payment, thank you) is fixed unless you build custom Components.

Functions cannot make external API calls. If your discount logic depends on an external service (a CRM, an ERP, a tax engine), you must pre-compute and cache the data in cart attributes or customer metafields. Functions are pure compute.

UI Extensions cannot persist state. Each render is independent. If you need state across renders, store it in cart attributes or customer metafields.

Components has a higher build cost. Custom checkouts are not a one-week project. Plan for 3 to 8 weeks of dedicated build plus QA across devices.

Migration patterns from common Script use cases

If you came from Scripts, here is where each common pattern lands in the new stack.

"Buy 2 get 1 free" Script: Order Discount Function. Pure business logic, no UI changes needed.

"Free shipping over $X" Script: Shipping Discount Function. Trigger condition is cart total.

"VIP customer 15% off" Script: Order Discount Function with customer tag check. Customer tags pass into Functions through the cart input.

"Hide expedited shipping for low-value carts" Script: Delivery Customization Function.

"Custom payment method order based on cart" Script: Payment Customization Function.

"Gift wrap upsell" Script: Cart Transformation Function plus a UI Extension that renders the upsell offer.

"Engraving message" Script: UI Extension that captures the message, Cart Transformation Function that holds it as a line item attribute.

What is the difference between Shopify Functions and Checkout UI Extensions?

Functions handle business logic. They decide what discounts apply, what shipping methods are available, and how the cart is transformed. Functions never render UI. Checkout UI Extensions handle UI. They inject React components into the checkout at defined extension points. UI Extensions never run business logic. The two work together. A Function might decide that a discount applies, and a UI Extension might render a message in checkout explaining the discount. They communicate through cart attributes and the standard checkout state. If you mix the responsibilities (running business logic inside a UI Extension or trying to render content from a Function) you will hit limits quickly.

Can I customize Shopify checkout without Plus?

Partially. Functions are available on all Shopify plans. So is the basic version of Checkout UI Extensions. What requires Plus: Checkout Components (the custom layout layer), Checkout UI Extensions at certain restricted extension points like the information step, and advanced features like Checkout Kit for agent commerce. If you are not on Plus, you can still build Functions for discount logic and inject UI Extensions at the open extension points. The default checkout layout, however, is what your customers will see.

How long does it take to migrate from Scripts to Functions?

Depends on your Script count and complexity. A typical Plus merchant with 5 to 15 active Scripts takes 2 to 4 weeks of focused dev time to migrate. If your Scripts are simple discount rules, a senior Shopify developer can move them in days. If your Scripts contain complex business logic with multiple branches, edge cases, and external dependencies, plan for 4 to 8 weeks. The wildcard is QA. Functions behave differently from Scripts under edge cases (empty carts, expired customer sessions, partial inventory). QA usually takes as long as the actual code work.

Do I need a developer to use Shopify Checkout Components?

Yes. Components is a developer-oriented framework, not a no-code page builder. You compose checkout interfaces using React-style component code, and you need somebody comfortable with Shopify's checkout extensibility APIs to do it well. Most Plus merchants use an agency for the initial Components build (3 to 8 weeks) and then handle ongoing tweaks in-house. If you do not have a Shopify-experienced developer on staff or an agency relationship, stick with UI Extensions on top of the default checkout for now.

What happens to my custom checkout after Scripts dies?

If your custom checkout depended on Scripts for logic, that logic stops running at 12:01am July 1. Customers will see your custom UI but the Script-based discounts, shipping rules, or payment customizations will not apply. The result depends on how the Script was used. Missing discounts mean customers pay full price. Missing shipping logic means default Shopify rates show. Missing payment customizations mean every payment method appears in default order. None of this breaks checkout. It just removes the custom behavior. If you have not migrated, do it today.

Is Shopify checkout extensibility ready for BFCM 2026?

Yes, but with caveats. Functions, UI Extensions, and Shop Pay are battle-tested and have handled BFCM before. Checkout Components is new (Spring 26 GA) and BFCM 2026 will be its first major peak traffic event. If you are running Components for the first time, our BFCM 2026 prep checklist calls out August as the month to load test it. The platform will scale. The question is whether your specific custom code has been tested at 10x your peak traffic. Test in August, fix in September, lock in October.

What we would do this week

Today is June 29. Scripts dies in 24 hours. Here is what we would do this week if we ran a Plus store.

Monday (today): Finish any in-flight Scripts to Functions migration. If you have not started, deploy a Functions-based fallback for your highest-revenue Script today.

Tuesday: Scripts dies at 12:01am UTC. Watch your checkout dashboards every 2 hours. Look for unexpected discount behavior, missing shipping options, and customer support tickets.

Wednesday: Confirm every Function is running correctly. Pull discount, shipping, and payment customization logs from the previous 24 hours. Anything that did not behave as expected gets a same-day fix.

Thursday: Audit your Checkout UI Extensions. Anything broken since the Scripts cutover gets fixed today.

Friday: Document what changed in your checkout this week. Brief the customer service team. Update internal runbooks.

The merchants who survive the Scripts cutover cleanly are the ones who treat July 1 as a major release, not an automatic event. Plan the week. Watch the dashboards. Fix the surprises before customers find them.

If you want help running the Scripts cutover week or building out Functions, UI Extensions, or Components, we run checkout extensibility engagements for Plus merchants. Email us at hello@exactwhy.com.

For context on what else shipped this quarter, our Spring 2026 Edition teardown covers all 200+ features from the June 17 release.