Once we factor in ongoing maintenance (not just the initial build), does a custom Shopify Function ever actually beat a third-party discount app's subscription cost over 2-3 years?
A custom Function does not beat a discount app on three-year cost for a single common rule. Deploi's Scripts-to-Functions record puts a build at $7,250 to $40,000 over three years against $1,800 to $16,700 on apps (Deploi decision record, September 2026). Custom wins when one rule set would otherwise need two or three subscriptions.
The arithmetic, stated plainly
| Path | Year 0 | Years 1 to 3 | Three-year total |
|---|---|---|---|
| Custom Function | $5,000 to $25,000, audit through parity-tested cutover for a one-to-six-rule inventory | Roughly 15 to 20% of build cost per year | $7,250 to $40,000 |
| App subscription | Install | Subscription, scaling with orders or seats | $1,800 to $16,700 |
All figures are illustrative Deploi estimates from the Scripts-to-Functions decision record (September 2026), not quotes and not market rates.
For context on what the subscription line looks like at the low end: Dealeasy is free to install up to 50 orders a month, then $9, $19 and $29 a month as order volume rises (per Shopify App Store, September 2026). At $29 a month, three years is $1,044. No custom build competes with that.
So the answer is usually no. Here is exactly when it flips.
One: when one rule set becomes several subscriptions. Our Scripts-to-Functions record names this as the buy path's defining trap: "One Script often becomes two or three subscriptions" (Deploi decision record, September 2026). Three apps at $49 a month is $5,300 over three years before anything scales, and now you have three vendors, three changelogs and three upgrade paths touching your checkout.
Two: when the app prices on orders and you are growing. A subscription banded by monthly order volume is a variable cost that rises exactly as the rule becomes more valuable. Model it at year-three volume, not today's.
Three: when the builder cannot express the logic. The same record names the failure mode precisely: "Preset builders flatten stacked logic, and the near-miss shows up as margin leakage, not an error message." An app that gets your stacking rules 95% right does not cost you the subscription. It costs you the 5%, silently, on every order that hits the gap. That is the only line in this comparison that can exceed the build cost, and it never appears in a subscription-versus-build spreadsheet.
Four: when the rule is a competitive asset. Pricing logic nobody else can copy is not a cost line.
What the build side's maintenance actually consists of
Not patching. Shopify maintains the runtime. Maintenance here is:
- Rule changes. Every tier change, every new segment, every exception.
- API version upkeep. Function APIs are versioned and
UnsupportedVersionErroris one of the twelve documented error types (per shopify.dev, September 2026). - Observability. Logs truncate at 1 kB and Shopify ships no merchant-facing alert, so somebody builds or buys the alerting. Our observability record puts that at $12,000 to $40,000 in year zero and $5,000 to $12,000 a year after (Deploi decision record, illustrative, September 2026). Count it on the build side of this comparison or the comparison is wrong.
What the buy side's hidden cost actually consists of
- Vendor risk on a pricing path. An app that changes its pricing model or gets acquired is a checkout migration.
- Data ownership. Your discount configuration lives in the vendor's database.
- The near-miss. See trap three.
When NOT to build
- When it is one common rule. Volume tiers, BOGO, free shipping over a threshold. These are solved products at $9 to $29 a month.
- When you are not on Plus. Custom apps containing Functions are Plus-only (per shopify.dev, September 2026). The comparison does not apply.
- When the observability budget is not funded. An unmonitored custom Function is a worse purchase than a monitored app, at any price.
The Deploi point of view
Our own position, from building on Shopify. Separate from the facts above.
- Our take: on three-year cost alone, apps win for common rules and it is not close. Build when the logic is not expressible, when one rule set fragments into several subscriptions, or when the pricing logic is itself the advantage. Cost alone almost never justifies it.
- What we’ve seen: the build cases that pay back are the ones where somebody could name the margin the app was leaking. The build cases that disappoint started from "we do not want another subscription," which is a preference, not a business case.
- Where we disagree: build-versus-buy content on this topic compares build cost against subscription cost and stops. The comparison is incomplete without the observability line on the build side and the near-miss line on the buy side, and those two are usually larger than the difference being argued about.
- What this page adds: the actual three-year totals from Deploi's own records on both paths, the specific subscription band a common discount app sits in, and the three named conditions under which the build genuinely wins. The parent answers a staffing question; this page prices it.
Reviewed by Martin Dejnicki, Director of SEO & AI Search. Facts verified 2026-09-14.
Where we worked this out
Our decision records