The checkout lane
Shopify opened, and
most builders drove past

On the morning of July 1, 2026, thousands of Shopify stores woke up dumber than they went to bed. Tiered discounts stopped tiering. Wholesale payment rules stopped ruling. Free-gift logic quietly forgot the gift. Shopify Scripts, the Ruby snippets that Plus merchants had been pasting into checkout since 2016, were switched off on June 30, exactly as promised, and I covered the merchant-side triage in what to do now that Scripts are off.

This post is about the other side of that shutdown. The builder side. Because while everyone framed June 30 as an ending, it was actually the loudest possible starting gun for a new app category, and most of the ecosystem slept through it.

Here's my claim, up front: checkout extensibility, with Shopify Functions as its engine, is the largest new platform surface Shopify has opened since the App Store itself launched in 2009. Bigger than Hydrogen, bigger than the POS SDK, and unlike those, it comes with a forced migration that hands app builders a motivated, deadline-driven customer base. I helped build the Shopify Partner Program, where the app economy's plumbing was laid, and I've watched builders respond to every platform shift since. The pattern this time is strange. The opportunity got treated like homework.

I have skin in this analysis from three directions. I was inside Shopify when the partner ecosystem was being designed, and that ecosystem now generates over $1B in annual partner revenue. I founded and sold a software company, getuptime.co, to Tiny, so I know what building in this ecosystem earns you at exit. And at WIN Brands Group we operated Plus stores whose checkouts ran Scripts through Black Fridays that I still have scar tissue from. Employee, builder, merchant. Three seats, same table, and from all three of them this looks like the same thing: a land grab that most people are late to.

So let's map it properly. What extensibility actually is, what the seven Function APIs let you build, what the limits are, why the miss happened, and where the durable money sits. If you'd rather start with the wider board, the Shopify ecosystem value map is the pillar this post hangs off.

The lane that opened on July 1

Start with what actually changed. Before June 30, 2026, custom checkout logic on Shopify lived in Scripts: Plus-only, Ruby, pasted into an editor by whoever on the team was brave enough. That logic belonged to the merchant. No app installed, no app paid for, no app in the loop. After June 30, the only sanctioned home for that logic is a Shopify Function, and a Function ships inside an app.

That sentence is the entire thesis of this post, so sit with it for a second. Shopify didn't just deprecate a scripting engine. It converted a decade of free, merchant-owned checkout customization into a product category that must now be bought. Every tiered discount, every payment-method rule, every shipping-rate tweak that used to be forty lines of Ruby is now either a public app subscription, a custom app build, or gone.

The scale of that conversion is not small. Scripts had a ten-year install base across the Plus tier, and Plus is where the volume lives. When we ran WIN's brands on Plus, every single storefront had Scripts in checkout. All of them, not some. Discount stacking on one, gift-with-purchase on another, payment-gateway hiding on the B2B side. Multiply that across the Plus base and you get a mass of business logic that all needed a new home during the twelve months before the shutdown, and much of it still hasn't found one. The merchants who missed the deadline are finding out at the checkout button, right now, in July.

In 2026 the Shopify App Store lists more than 17,600 apps, per Uptek's April 2026 App Store census, and the catalog grew roughly 71% between early 2024 and Q1 2026. Yet search that store for serious Functions-native checkout logic and the shelf is oddly bare. Plenty of legacy discount apps wearing a fresh coat of paint. Very few products designed from the WebAssembly runtime up. That gap between forced demand and native supply is the lane.

What checkout extensibility actually is

Checkout extensibility is Shopify's name for the whole replacement system: a set of sanctioned building blocks that customize checkout without touching checkout's code. The old world was one big hackable Liquid file, checkout.liquid, that Plus merchants could edit directly. Powerful, fragile, and impossible for Shopify to upgrade underneath. The new world splits that power into five primitives, each with its own job and its own rules.

The architectural bet is worth understanding, because it explains why this system will outlive every workaround. In the checkout.liquid era, Shopify couldn't ship checkout improvements without breaking somebody's customizations, so checkout improvements mostly didn't ship. Extensibility inverts the deal. Merchants and apps get defined slots with defined contracts, and Shopify gets to rebuild the road under them without breaking the cars. One-page checkout, Shop Pay improvements, the agentic checkout work I covered in agentic commerce for Shopify brands: all of that ships continuously because customizations now live in slots instead of forks.

For an app builder, the practical translation is this. A Function is where your logic lives. A UI extension is where your interface lives. A web pixel is where your measurement lives. Most durable checkout apps in 2026 are a braid of the first two: a Function computing the decision, an extension showing it. Understand the seams between the five primitives and you understand the product architecture of the whole category.

The seven Function APIs, and what each one sells

As of mid-2026, seven core Function APIs are in production, per Shopify's Function API reference. Each one is a different lever inside the checkout pipeline, and each one maps to problems merchants already pay to solve. The discount trio has been consolidated under a unified Discount API that can touch products, orders, and shipping from a single function, which matters more than it sounds: one app can now own a merchant's entire promotion stack.

Beyond the core seven, Shopify has been shipping narrower targets on a steady cadence since 2022: order routing rules, fulfillment constraints, pickup option generation. Each new target is a fresh slice of platform surface that usually goes unclaimed for months. Watching the Functions changelog is, at this point, a legitimate product-discovery strategy, the same way watching the Editions drops is.

Two of the seven deserve a highlight because they had no Scripts equivalent at all. Cart transform can restructure what's actually in the cart, including raising prices on components, which Scripts could never do; it's the API that finally made real bundling native. And validation can stop a checkout cold with a custom message, which turns compliance and B2B order rules from a support headache into a product. The other five map roughly onto what Scripts did, which is exactly why the migration demand concentrated there first.

What Functions do that Scripts never could

It's tempting to read Functions as Scripts with a compliance haircut. That reading is wrong in both directions: Functions are more constrained in some ways and much more capable in others, and the capability side is what builders keep underrating.

The performance line matters more than any other for anyone who has operated a real store at peak. Scripts ran as interpreted Ruby on shared infrastructure, and under Black Friday load the latency got ugly. We lived this at WIN: checkout slowdowns on the biggest revenue day of the year, traced to promotion logic we ourselves had written. Functions compile to WebAssembly and execute inside the checkout pipeline in around 5 milliseconds, every time, because Shopify enforces the budget rather than suggesting it. That's a different class of infrastructure, not a refactor.

But the distribution line is where the business changed. Scripts had no channel: logic was written per-store, by an agency or a technical founder, and no one built equity doing it. Functions ship inside apps. Which means checkout logic now has what checkout logic never had before: a store, a subscription price, a review count, and a compounding asset behind it. The forty-line Ruby snippet that an agency billed $2,000 to write once is now an app earning $49 a month from four thousand merchants. Same logic. Different business.

A worked example: one Scripts pattern, reborn as a product

To make the abstraction concrete, take the single most common Script I saw in the wild: tiered volume discounts with payment-method rules layered on top. Spend $500, get 10% off. Spend $1,500, get 15% and unlock net-30 invoicing, but only if the customer carries a wholesale tag. In the Scripts era that was maybe sixty lines of Ruby, written by an agency, invoiced once at $2,000, then orphaned. When it broke, the merchant emailed the agency. If the agency was gone, the merchant was stuck. I inherited exactly this situation on two of WIN's brands, and untangling another team's checkout Ruby during Q4 prep is an experience I wouldn't wish on anyone.

Now walk the same pattern through the new stack. The tier math lives in a discount Function reading cart totals against thresholds the merchant set in your app's admin. The invoicing rule lives in a payment customization Function checking a customer tag Shopify hands it at runtime. The wholesale minimum lives in a validation Function that blocks checkout under $250 with a message you let the merchant write. Three Functions, one app, one settings screen. Setup takes eleven minutes, not a statement of work.

And the merchant gets something no agency ever delivered: when Shopify changes checkout, nothing breaks, because the contract between the Function and the pipeline held. If the merchant wants the threshold moved from $500 to $600, that's a slider, not a ticket. When Black Friday hits, the logic runs in its 5 milliseconds like it's a Tuesday in March. The merchant pays $79 a month, forever, happily, because the thing it replaced cost more and worked worse. Multiply by every store that ever ran that Script, and you see why I keep calling this a category and not a feature.

The limits, and why they're your moat

Every conversation I have with a founder about Functions hits the same wall about twenty minutes in: the limits. They are real, they are hard, and per Shopify's Functions documentation they are non-negotiable. An 11 million instruction execution budget. A 256KB cap on the compiled WASM binary. And no network calls at runtime, with one narrow exception: custom apps on Plus and Enterprise can request network access, with Shopify's explicit approval, per the platform's 2026 developer docs.

No network calls is the one that breaks brains. Your Function cannot phone your server, hit an external pricing API, or check a database mid-checkout. It runs entirely on what Shopify hands it: the cart, the customer, the configuration you stored ahead of time. Coming from Scripts, which at least lived server-side where you controlled the environment, this feels like a straitjacket.

The reframe I give founders, and I mean it literally: the limits are the moat. A checkout app on Functions is forced into a specific architecture, where all the intelligence happens ahead of time and gets precomputed into metafields the Function reads at runtime. Sync jobs, data pipelines, config compilers: the actual product is everything that happens before the 5 milliseconds. That architecture is hard to build well. Which is the point. The no-code app generation that flooded the store between 2020 and 2024 cannot wrap a UI around this the way they wrapped one around a REST endpoint. The teams that master the precompute pattern are competing in a thinner field than any other category in the store.

The instruction budget produces a second, quieter moat: language choice. In 2026, agency engineering write-ups measured Rust implementations using roughly 7x fewer instructions than JavaScript compiled through Javy for the same output, a pattern B2 Agency documented in a 2026 migration case study after a TypeScript Function blew the budget on large B2B carts. JavaScript is fine for a v1 on small carts. At 200-line wholesale orders, it isn't, and the public apps that win the B2B segment will be the ones that took the Rust rewrite seriously before their merchants hit the ceiling.

One more limit worth naming because it shapes product design: Functions are pure compute with no UI. If your logic needs to explain itself to the shopper, that's a checkout UI extension. If it needs configuring, that's your app's admin surface. The teams that treat those three layers as one product, rather than a Function with an afterthought bolted on, ship the things merchants describe as "it just works." That phrase, in App Store reviews, is worth real money.

Why most builders missed it

If the opportunity is this legible, why is the shelf still thin in July 2026? I've asked some version of this question to every app founder I advise, and the answers cluster into four patterns. None of them are stupid. All of them are wrong.

There's a fifth factor I'd add from my partner program years: Shopify's own communication optimized for merchant safety, not builder excitement, and that was the right call for the platform. You don't hype a surface while you're decommissioning its predecessor under live traffic. But it means the builder-facing story was never really told at full volume. The market signal exists; it's just sitting in changelogs and deprecation notices instead of keynotes. The best opportunities usually read like chores from the outside, and I made a version of this argument in how to build a Shopify app in 2026: the app ideas that still work are the ones that look like plumbing.

Three deadlines, one demand wave

Platform transitions usually diffuse slowly. This one has a schedule, and the schedule is doing the marketing for you. Three dates, stacked over twelve months, each pushing a different tranche of merchants into needing the thing a Functions-native app sells.

In 2026 the merchants hit by these deadlines are not browsing for nice-to-haves; they are replacing things that used to work, on a date they didn't pick. That's the strongest purchase intent that exists in software. And the third tranche, the August 26 wave, is the one most builders are undersizing, because non-Plus is where the merchant count actually lives. Shopify has been auto-upgrading unmigrated stores since January 2026, per Shopify's migration documentation, which means a steady drip of broken customizations is converting into app installs every week this summer, with the firehose scheduled for late August.

Demand waves like this one also change acquisition math. App Store search is intent-driven: when thousands of merchants search "payment rules" or "discount stacking" in the same quarter, category-page rank and listing conversion compound in a way normal months never allow. The distribution mechanics are in the app distribution playbook, but the short version is that a demand spike this predictable is the cheapest customer acquisition an app founder will ever see. The wave was announced two years in advance. It's still breaking.

The opportunity map: six plays worth building

Enough context. This is where I'd point a team, ranked roughly by how durable I think the resulting business is. The pattern across all six: the best Functions businesses sell an outcome merchants already understand, with the WebAssembly part invisible. Nobody buys "a Function." They buy margin protection, B2B order control, and promotions that don't require a developer.

Play 03 deserves one more paragraph, because it's the one I push hardest in advisory conversations. Across the brands I've operated and advised, most promotional discounting fails contribution-margin math: the lift never clears the giveaway. Scripts-era discount logic couldn't know that, because it saw the cart and nothing else. A Functions app doesn't have that excuse. Your sync layer can precompute landed cost and margin into metafields, and your discount Function can refuse to breach a floor the merchant sets once. That is a fundamentally better product than percentage stacking, it's the same math I built the DTC profitability calculator around, and the first app that makes it effortless owns a category.

Notice also what's not on the map: generic "checkout upsell" plays. Post-purchase upsells are real money, but the incumbents there already survived the 2025 Plus migration, and you'd be walking into the one corner of extensibility that is already crowded. The empty shelf is in logic, not offers.

Deeper on play 01: B2B is where the complexity pays

B2B checkout control tops my ranking because the problems are ugly in the way that produces pricing power. A hybrid wholesale operation needs customer-specific payment terms, order minimums that vary by account tier, delivery options that differ for freight versus parcel, and a validation net that stops a $300 order from a net-60 account. Shopify's native B2B suite handles the scaffolding, and I covered its net-terms mechanics in the B2B net terms post, but the last mile of any real wholesale program is always custom logic. That last mile used to be a Plus Script. Now it's four Functions and a settings page, and the operator writing the check compares your $299 a month to a sales-ops hire, not to another app.

Deeper on play 02: cart transform has no incumbent

Every other API on the map replaced something, which means every other play fights a legacy install base somewhere. Cart transform replaced nothing. The ability to expand a bundle into its component SKUs for fulfillment while presenting one line at one price to the shopper simply did not exist in checkout before this API. The winners here will look less like discount apps and more like product infrastructure: kit builders for supplement brands, configurators for furniture, machine-plus-consumables logic for the espresso and razor crowd. When a category's core mechanic is only possible on the new surface, being early is the whole game.

Deeper on play 03: the CFO's discount app

The margin-aware promotion play is the contrarian one, so let me put weight behind it. Discounting is the largest self-inflicted wound in DTC; across the brands I've operated and advised, most promotions never clear their break-even lift, a math problem I walked through in the contribution margin per order post. The fix is a floor, not better creative: a discount engine that knows contribution margin per SKU and refuses to breach it. Functions make that floor enforceable at the exact moment it matters, inside checkout, with no human in the loop. Sell that to the CFO, not the marketer. Marketers churn tools every quarter. CFOs renew the thing that stopped the bleeding.

The economics of a checkout-logic app

Let's put numbers on whether this is worth a year of your life, because the App Store's averages are grim and I'm not going to pretend otherwise. In 2026, an independent analysis of 7,378 Shopify apps by Week One Labs found average revenue of about $20,000 a month against a median of just $725. Read that pair of numbers carefully. The store is a power law: a thin crust of apps earns nearly everything, and the median app is a hobby.

So why am I bullish on this category specifically? Because the power law isn't random. It sorts on three variables, and checkout logic scores unusually well on all three.

Retention. Checkout logic is the stickiest workload in the store. A merchant will churn an email tool the month growth slows, but the app computing their B2B payment rules is load-bearing infrastructure; removing it breaks checkout tomorrow. In a store where the median app dies of churn, the category with structural retention wins the compounding game. I've written before that churn is a symptom, not the problem; checkout logic is what the cure looks like when it's built into the category itself.

The rev-share structure. Shopify takes 0% on your first $1 million USD in lifetime revenue, counted from January 1, 2025, and 15% after that, per Shopify's developer revenue share terms. The 2025 shift from an annual reset to a lifetime cap stung mature apps, but for a new build the deal is unchanged and blunt: your first million is yours. At a $59 average subscription, that's your first fourteen hundred merchant-months of revenue with no platform tax at all.

Willingness to pay. Checkout logic prices against consequences, not features. The merchant isn't comparing you to a $9 popup; they're comparing you to a $150-an-hour agency retainer, a failed compliance audit, or a Black Friday incident. Apps in the plays above clear $49 to $299 a month without friction, and the B2B tier goes higher. The valuation implications compound too: an app with checkout-logic retention gets underwritten near the top of the multiple bands I walked through in what a Shopify app is worth at $500K ARR.

Run the boring math. Four hundred merchants at $99 a month is $475K ARR, under the rev-share cap the whole way, in a category where a 3% monthly churn rate would be considered bad. That math never needs a venture deck. It's a sellable company, and the path from zero to that number is the standard climb I mapped in from MVP to $1M ARR.

The fork in the road: agency revenue or app equity

One economic fork deserves naming, because the Scripts sunset created a boom in both directions. Migration work is everywhere right now: agencies are quoting five figures to rebuild Script logic as custom Functions, and the work is real. But custom builds are the 2016 business model wearing 2026 clothes: revenue that stops when you stop, attached to a client list instead of an asset. The same engineering effort, pointed at a public app, compounds into reviews, rank, and a sellable line item. I sold a software company in this ecosystem; nobody acquires a backlog of statements of work. If you're an agency reading this with six Functions rebuilds on the board, you are sitting on validated product research someone else will eventually ship. Ship it yourself.

Plus-only vs every plan: how the market actually splits

The plan gates confuse everyone, including people building in the category, so this is the clean version. The Plus wall didn't disappear with Scripts; it moved. Knowing where the wall now stands is how you size a product honestly.

The strategic read: backend logic is a mass-market product now, while checkout interface is still a Plus product. That cleaves the opportunity into two distinct businesses. A Functions-only app (payment rules, discount logic, validation) can sell to the entire merchant base, which is where the install volume and the August 26 wave live. An interface-heavy app (custom fields at the shipping step, in-checkout upsell components) sells into Plus, a smaller pond where the fish are bigger and the $2,300-a-month plan floor I broke down in the Shopify plans and pricing decoder guarantees budget exists.

The mature move is a product line that spans both: logic tier for everyone, interface tier as the Plus upsell. Merchants upgrade plans more often than they switch logic vendors, so the app that lands on a standard-plan store today inherits the Plus budget when that store grows into it. Land wide, expand up. It's the partner program's oldest play, and it still works.

Building on the new primitives: field notes

This isn't a tutorial, but there are five decisions every team building here gets right or regrets, and they're worth naming from the advisory side of the table.

Pick Rust if you're serious, and decide early. Shopify maintains first-class toolchains for Rust and for JavaScript via Javy, its JS-to-WASM compiler, per Shopify's own engineering write-up. JavaScript gets a prototype out in a weekend, and for small carts it holds. But the instruction budget punishes dynamic languages on big carts, and rewrites hurt more after you have ten thousand installs. If B2B or large-cart merchants are anywhere in your roadmap, start in Rust and skip the migration story entirely.

Design the precompute layer first. The Function is the last 5 milliseconds of your product. The real system is the pipeline that turns merchant intent into metafield state ahead of time: config compilers, sync jobs, and the failure handling around them. Teams that architect the precompute layer first ship stable products; teams that start from the Function and discover the pipeline later ship support queues.

Make the merchant UI the product. The winning Scripts-era agencies sold code. You're selling the absence of code. A wholesale operator should express "net-30 invoicing appears only for tagged accounts over $2,000" in a settings screen a non-technical person trusts. Every hour spent on that configuration surface converts better than an hour spent anywhere else, and the same is true of your listing: checkout apps live and die on the trust signals I covered in the App Store listing conversion post.

Respect the review gate. Checkout-adjacent apps get Shopify's strictest app review, and they should: this code runs inside the money path. Budget real time for it, instrument your Function's outputs so you can prove behavior, and treat the review process as a moat marker rather than friction. Every hoop is one more reason the popup factories stay out of your category.

Price against the alternative, not the category. The alternative to your app is not another app. It's an agency retainer, a custom build, or a merchant living without logic their old Scripts gave them for free. Anchor there. The pricing model calculator will show you how the same feature set performs as flat, tiered, or usage pricing; checkout logic almost always supports tiered, and the top tier is higher than you think.

The dependency question

Every thesis needs its stress test, and this one has an obvious one: you'd be building on the most tightly controlled surface of a platform that just demonstrated, twice in twelve months, that it will delete whole categories of customization on a schedule. Scripts builders got a decade; checkout.liquid trackers got less. What stops Functions from being next?

Nothing stops it, and pretending otherwise would be selling you something. I wrote the general framework in the platform dependency risk post, and it applies here in full. But the risk profile of Functions is meaningfully different from what it replaced, for one structural reason: Scripts and checkout.liquid were technical debt Shopify inherited and needed gone. Functions are the destination Shopify spent four years building. Platforms kill their debt. They rarely kill their destination, because the destination is what lets them keep shipping. Extensibility is the architecture that made one-page checkout and the agentic commerce work possible at all; Shopify needs it healthy in a way it never needed Scripts.

The realistic risks are quieter than deprecation. Shopify absorbs your feature into the core product: real, watch what Editions ships natively each cycle, and stay in the logic that's too merchant-specific to platformize. Shopify tightens API terms: real, which is why the margin between your price and the value delivered needs to stay wide. Rev share climbs past 15% someday: possible, and priced into every platform business. None of these are reasons not to build. They're reasons to build the way the durable ecosystem companies always have: close to merchant money, differentiated by domain depth, with economics that survive a term change. Platform risk is the rent here, not a verdict on the category, and checkout logic can afford that rent better than most categories can.

What I would do, in order

If I were starting an app company today, this is the sequence, concretely.

Ship a wedge before August 26. Pick one Scripts pattern with proven demand (payment-method rules and shipping-option shaping are the two I'd shortlist), build the Functions-native replacement with an opinionated setup flow, and be listed while the non-Plus force-migration is still converting broken checkouts into App Store searches. The wave does your launch marketing; you'll never get a cheaper wedge.

Then expand into one durable play. The wedge buys installs and reviews, not a business. Within two quarters, deepen into whichever of the six plays your early merchants pull you toward; the pull will be obvious from support tickets. B2B checkout control and margin-aware promotions are where I'd want to land, because both price high, churn low, and compound with Shopify's own roadmap instead of against it.

Build the team for the constraint. One engineer who genuinely understands the WASM toolchain and the precompute architecture is worth three who can wrap a REST API. This category's hiring filter is its moat; use it on purpose.

The window here is not infinite. Twelve to eighteen months from now, the migration wave will be spent, the shelf will have filled, and the winners will be raising prices with four hundred reviews behind them. Platform surfaces reward the builders who show up while everyone else still thinks it's a chore. This one is still early, barely.

Frequently asked questions

A note on sources: the Function API surface, plan availability, execution limits, and revenue share terms (0% on the first $1 million USD lifetime from January 1, 2025, then 15%) are from Shopify's Function API reference, the Functions developer documentation, and Shopify's revenue share terms, retrieved July 2026. The migration dates (Plus checkout extensibility deadline August 28, 2025; Scripts shutdown June 30, 2026 with the April 15 edit freeze; non-Plus force-migration August 26, 2026 with auto-upgrades rolling since January 2026) are from Shopify's help center and changelog. The App Store census figures (17,600+ apps as of April 2026, roughly 71% catalog growth from early 2024 to Q1 2026) are from Uptek's 2026 App Store statistics and corroborating trackers. The revenue distribution (average about $20,037 a month versus a $725 median across 7,378 analyzed apps) is from Week One Labs' 2026 benchmark analysis. The Rust-versus-JavaScript instruction benchmarks are from 2026 agency engineering write-ups, including B2 Agency's migration case study, and Shopify's Javy toolchain is documented in Shopify's engineering blog. The opportunity ranking, the durability read on each play, the precompute architecture argument, and the window timing are mine, from building the Partner Program, operating Plus checkouts through peak seasons at WIN Brands Group, and selling a software company, getuptime.co, to Tiny.