Shopify Scripts are gone: a planning guide for moving to Functions

A note on how to read this one: this is a planning guide based on Shopify's own announcements and documentation. It isn't a write-up of a Function I've shipped. Where it matters, I've linked the sources and said what I haven't verified.

What happened

Shopify Scripts, the Ruby-based customisations that ran in checkout for Shopify Plus stores, were wound down on a published schedule:

• 15 April 2026: editing and publishing Scripts stopped.
• 30 June 2026: Scripts stopped executing.

The replacement is Shopify Functions: custom logic that runs on Shopify's infrastructure, for things like discounts, shipping and payments.

If a store relied on a Script and nothing replaced it, the behaviour it provided is now gone. That could be a discount rule, a hidden shipping option, a payment method restriction, or something quieter.

Step 1: find out what the old Scripts did

Shopify provides a Scripts customisations report that helps identify which of your current customisations transition to Functions or to public apps. Start there, then verify by reading the code.

For every script, write down in plain language:

• What it did (for example, "10% off for customers tagged wholesale").
• Who depends on it (marketing, operations, B2B customers).
• When it applied (which products, customers, markets, order values).
• What happens if it's missing (revenue, margin, customer trust).

The business rule matters more than the code. You're replacing a behaviour, not translating a file.

Step 2: map each behaviour to the right tool

Functions are split into separate APIs by purpose. At a high level:

| What the script did | Where to look | |---|---| | Discounts on items, orders or shipping | The Discount Function APIs | | Restructuring or bundling cart lines | Cart Transform | | Rules that block or validate checkout | Cart and Checkout Validation | | Hiding, renaming or reordering shipping options | Delivery Customization | | Hiding, renaming or reordering payment methods | Payment Customization |

Treat this table as a map for your research, not a final answer. Check Shopify's current documentation for exactly what each API can and can't do. Some behaviours map cleanly, some need a different approach, and some are better served by an existing public app.

Step 3: decide build, buy or retire

For each behaviour:

1. Is a public app already doing this well? Often the cheapest, safest option, particularly for common discount logic.
2. Does it need custom logic? Then a Function, packaged in an app you own, is the route.
3. Is it still needed at all? Old scripts accumulate. Some rules may no longer matter, and retiring them is a legitimate answer.

Step 4: build and test safely

If you're writing a Function:

• Work in a development store, not production.
• Keep the logic small and testable: Functions take input and return operations, which suits unit testing.
• Test the edge cases: empty carts, mixed carts, zero prices, unusual quantities, customers without tags.
• Test against real checkout flows, including the order that shouldn't be affected.
• Watch for performance limits. Functions are expected to run quickly, so avoid heavy work.

Step 5: roll out carefully

• Compare behaviour against the old Script's documented rules.
• Roll out in a low-risk window, with someone watching orders.
• Keep a clear record of what was replaced by what.

What I'd flag to a client

• Missing behaviour may already be live. If nobody replaced a Script, find out now what's been going wrong in checkout since the end of June.
• Not everything maps one-to-one. Set expectations early.
• Plan for ongoing change. Shopify's checkout extensibility continues to evolve, so build with the current documentation, and keep logic modular.

Sources

• Shopify's announcement: Shopify Scripts will be deprecated on June 30, 2026 (shopify.dev/changelog).
• Shopify Help Center: Transitioning from Scripts to Functions.

I haven't verified every detail of each Function API's current capabilities for this post. Read the current docs for the API you plan to use.