Should You Build or Buy Custom Discount Types on Shopify Plus?
Custom discount types are a BUILD on Shopify Plus once the rule outruns what packaged apps express, at $8,000–$25,000 one-time (Deploi estimate, illustrative). The function needs Plus, because only Plus stores can install custom apps that contain Function APIs. Buy first when Discounty or Dealeasy covers the rule at $9–$49.9/month (verified Sep 2026). Build on the unified Discount Function API; the legacy per-type discount APIs are deprecated.
Your profile — see how the verdict shifts
- Confidence
- High — Checked three live listings on 2026-09-05: SMART Functions Creator (5.0★, 110 reviews, free, Built for Shopify), Discounty (4.9★, 1,240 reviews) and Dealeasy (4.9★, 624 reviews), against a wider category that also holds BOGOS at 5.0★ on 4,345 reviews, Regios and Bold. Packaged apps express volume, tiered and BOGO rules well; none exposes an arbitrary computed rule that combines cart, customer and metafield conditions. Shopify's own docs state that only stores on a Shopify Plus plan can use custom apps that contain Shopify Function APIs, cap active discount functions at 25 per store, and limit the fetch network target to custom apps installed on Plus and Enterprise stores. The legacy order-discounts reference now redirects to the unified Discount Function API's migration section, so a new build targets the unified API.
- Reference scenario
- $20M–$100M GMV · Shopify Plus · a discount rule the native engine and packaged apps can't express · agency or in-house dev bench
- As of
- September 2026
Decision at a Glance
| Your profile | Verdict | Why |
|---|---|---|
| Not on Plus (Basic, Grow or Advanced) | BUY | Only Plus stores can install custom apps that contain Function APIs, so a custom discount function isn't available to you. Stores on any plan can use App Store apps that bundle functions, and Discounty, Dealeasy and the free SMART Functions Creator are that lane. |
| Plus · volume, tiered, BOGO or spend-threshold rule | BUY | A packaged app already expresses these shapes for $9–$49.9/month (verified Sep 2026), and the vendor absorbs API version bumps. Spending $8,000+ (Deploi estimate, illustrative) to rebuild a rule Discounty ships on day one is the wrong use of a Plus dev budget. |
| Plus · rule combines cart, customer and metafield conditions no app exposes | BUILD | The fork this page exists for. A custom discount function reads your own metafields, applies exactly the computed rule marketing specified, and costs $8,000–$25,000 once (Deploi estimate, illustrative) instead of a subscription that still can't express it. |
| Plus · several custom rules, POS parity or external data at checkout | BUILD | Still a build, with architecture attached: 25 active discount functions per store is the ceiling, the fetch target needs Shopify-enabled network access on Plus or Enterprise, and POS honors function discounts from POS app 9.10. Consolidate rules into fewer functions and precompute into metafields. |
What Custom Discount Types Actually Drives
| Outcome | Impact | How it works |
|---|---|---|
| Revenue — direct | High | A rule that fires exactly where margin allows, and nowhere else, protects the margin an approximated packaged rule leaks on every qualifying order. |
| Customer experience | Medium | Function discounts apply consistently in cart, checkout and, from POS app 9.10, in store, so the price a customer sees is the price they pay on every channel. |
| Operational efficiency | Medium | One configurable function replaces the stack of overlapping discount apps most stores accumulate, and marketing changes a threshold in settings rather than filing a ticket. |
| Data & insight | Medium | Rule configuration held in your own metafields is queryable alongside orders, so you can report which rule produced which discount instead of reading a vendor dashboard. |
Spend ceiling: Size the spend against the margin the rule protects, not the number of discounts you run. A rule worth $8,000–$25,000 (Deploi estimate, illustrative) is one where an approximated packaged rule leaks more than that in a year; below that line, a $9.9/month app is the correct answer (verified Sep 2026).
What buying enables (top apps)
- + Volume, tiered and BOGO campaigns live the same afternoon, for free up to 10 discounted variants or 50 orders a month (verified Sep 2026)
- + Vendor-maintained functions that absorb API version bumps and the legacy-to-unified Discount API migration
- + A no-code function builder, free, that authors real Shopify Functions for discounts and checkout customizations
- + Built for Shopify listings at 4.9–5.0★ across 110 to 1,240 reviews, so the buy risk is low
What building additionally unlocks
- + A computed, context-aware rule across cart, customer and metafield conditions that no packaged app exposes
- + Merchant-facing settings for every threshold, so the rule changes without a redeploy or a support ticket
- + Configuration data in metafields you own, reusable by reporting and personalization
- + One function instead of several apps against the 25-active-function-per-store ceiling
Find Your Verdict in 3 Questions
Is the store on Shopify Plus?
Yes: Go to question 2.
No: Your verdict: BUY. Only Plus stores can install custom apps that contain Function APIs, so App Store apps with bundled functions are your only lane.
Does a packaged discount app, or the free SMART Functions Creator, express the rule exactly as marketing specified it?
Yes: Your verdict: BUY. Discounty or Dealeasy at $9–$49.9/month (verified Sep 2026) beats a build for any rule it already ships.
No: Go to question 3.
Does the rule depend on data that lives outside Shopify at the moment of checkout?
Yes: Your verdict: BUILD. Precompute that data into metafields the function reads; the fetch target needs Shopify-enabled network access and only custom apps on Plus or Enterprise qualify.
No: Your verdict: BUILD. One configurable function on the unified Discount Function API at $8,000–$25,000 (Deploi estimate, illustrative).
The TCC Scorecard — 12 Dimensions
TCC — Total Cost of Capability: what it actually costs to have this capability over three years, whichever way you get it. Each dimension is scored 0–5 for both paths. How we score →
| Dimension | Buy | Build | Why |
|---|---|---|---|
| Cost | |||
| Acquisition & implementation | Discounty or Dealeasy is live the same afternoon, while a production discount function with settings, tests and deployment runs an estimated 3–6 weeks (Deploi estimate, illustrative). | ||
| Recurring fees | Paid tiers run $9–$49.9/month (verified Sep 2026), which is cheap until a campaign crosses a variant or order threshold; the build carries no subscription, only upkeep. | ||
| Maintenance & upgrades | The vendor absorbs quarterly API versions and the legacy-to-unified Discount API migration; on your own function those land on your team at roughly 15–20% of build cost per year (Deploi estimate). | ||
| Switching & exit | A packaged app's discounts go with the app when you uninstall it and the campaign configuration lives in the vendor's admin; your function's configuration sits in your own metafields and repo. | ||
| Risk | |||
| Vendor risk | A healthy category with 1,240- and 624-review listings is low vendor risk, and a first-party function has no vendor to lose at all. | ||
| Security & compliance surface | Discount apps read cart and customer data through App Store review; a custom function runs inside Shopify's sandbox with only the input query you wrote, and no third party sees the cart. | ||
| Platform-deprecation exposure | The legacy per-type Discount Function APIs are deprecated in favor of the unified Discount Function API, and a custom function you wrote against the old shape is your migration, while a vendor ships theirs for everyone. | ||
| Value | |||
| Fit to requirement | The reference scenario is a rule no packaged app exposes, so the app's fit is by definition partial, and the function implements the exact computation marketing specified. | ||
| Time to market | Today versus about a month, and the month only counts if the rule genuinely can't be approximated by a packaged shape in the meantime. | ||
| Performance & scale | Both lanes run as Shopify Functions inside the 11-million-instruction budget for carts up to 200 line items, so neither adds storefront scripts; a Rust function leaves the most headroom on large carts. | ||
| Data ownership & AI-readiness | A custom function reads configuration from metafields you own under a reserved namespace, so the same data feeds reporting and personalization; a vendor's campaign settings stay in the vendor's admin. | ||
| Focus & opportunity cost | Nobody wants to own discount plumbing, though a single well-scoped function is a bounded project rather than a product, and it removes the stack of overlapping discount apps most stores accumulate. | ||
The App Landscape
| App | Status | Pricing | Best for |
|---|---|---|---|
| SMART Functions Creator | Live — 5.0★, 110 reviews; Built for Shopify. A no-code builder that authors Shopify Functions for discounts, payment customizations, delivery customizations and validations, distributed as a public app so it works on any plan. Its ceiling is the rule shapes the builder exposes; try it before paying for a build. | Free; the entire app is free to install with no paid tiers (verified Sep 2026) | Testing whether a no-code function expresses your rule before committing to a custom build |
| Discounty: Bulk Discount Sales | Live — 4.9★, 1,240 reviews; Built for Shopify. Volume, tiered and BOGO campaigns priced by live discounted variants, from 10 on the free Starter plan to 10,000 on the top tier, with countdown timers and customer-segment targeting on higher plans. | Starter free with 10 live discounted variants; Lite $0.99/month first month, then $9.9/month or $99/year; Essential $1.99/month first month, then $29.9/month or $299/year; Discounty $2.99/month first month, then $49.9/month or $499/year; 3-day free trial on paid plans (verified Sep 2026) | Campaign-style volume and BOGO discounts across a catalog, on any plan |
| Dealeasy: Volume Discounts App | Live — 4.9★, 624 reviews; Built for Shopify. Volume discounts priced by monthly order count rather than variants, free to install up to 50 orders a month. | Free to install up to 50 orders/month; Growth $9/month up to 500 orders/month; Pro $19/month up to 1,000 orders/month; Ultimate $29/month for 1,000+ orders/month; 30-day free trial on paid plans (verified Sep 2026) | Straightforward quantity breaks where order volume, not catalog size, drives the bill |
| Custom discount function on the unified Discount Function API (custom app) | Build lane — The only lane for a computed, context-aware rule: a function in your own custom app, installable only on Shopify Plus, reading cart, customer and metafield inputs you define. Built against the unified Discount Function API, since the legacy Order, Product and Shipping Discount APIs are deprecated. Honors the 25-active-function-per-store ceiling. | $8,000–$25,000 one-time plus upkeep (Deploi estimate, illustrative) | Plus merchants whose discount logic no packaged app or no-code builder expresses |
The Build Path
- Model the rule as an input query over your own metafields: Put the data the rule needs, such as campaign thresholds, customer tiers and product exclusions, into metafields under a reserved app-owned namespace so other apps can't collide with them. Keep the input query under 3,000 bytes and a calculated cost of 30, and remember metafield values over 10,000 bytes aren't returned.
- One function on the unified Discount Function API, with merchant settings: Target the unified Discount Function API rather than the deprecated per-type Order, Product or Shipping Discount APIs. Expose thresholds through the function settings component so marketing changes a percentage without a redeploy. One function with configuration beats five hard-coded ones against the 25-active-function ceiling.
- Rust or JavaScript, tested with run and replay: JavaScript functions hit the instruction limit sooner than Rust, per Shopify's own guidance, and the budget is 11 million instructions for carts up to 200 line items. Unit-test with the CLI's function run against fixture carts and use function replay on logged production inputs; log streaming and replay have been generally available since Shopify CLI 3.66.
- Precompute instead of fetch: Network access for functions has to be enabled by Shopify, is limited to custom apps on Plus and Enterprise stores, and isn't available on development stores. Shopify's docs say fetching from metafields during checkout is more efficient than an external call, so write external data into metafields ahead of time and let the function read it.
- Effort band
- $8,000–$25,000 for one production discount function with settings UI, fixtures and deployment — Deploi estimate (illustrative); lands in the $10–25K contact-form band, or $25–75K when several rules, POS parity or an external-data dependency are in scope
- Typical timeline
- 3–6 weeks to a production function (Deploi estimate, illustrative)
- Maintenance, honestly
- ~15–20% of build cost per year (Deploi estimate): roughly $1,500–$5,000/yr (Deploi estimate, illustrative) for quarterly API version bumps, the rule changes marketing asks for, and keeping fixtures current as the catalog and customer tiers change.
- What you own — and what you take on
- You own: the rule, its configuration data in your metafields, the test fixtures and the deployment history. You take on: the 25-active-function ceiling, API version upkeep, and the discipline of not rebuilding a rule that a $9.9/month packaged app already ships (verified Sep 2026).
3-Year Total Cost of Capability
| Buy (app path) | Build (custom path) | |
|---|---|---|
| Year 0 (setup) | $500–$2,000 (configuration and campaign setup time) | $8,000–$25,000 |
| Years 1–3 (recurring) | $360–$1,800 (subscription across three years) | $4,500–$15,000 (upkeep and rule changes) |
| 3-year total | ≈$860–$3,800 | ≈$12,500–$40,000 |
- † All figures illustrative samples for the reference scenario — not quotes, not verified pricing.
- † Buy column assumes a mid-tier packaged discount app plus internal time to configure and re-check campaigns each season.
- † Build column covers one discount function on the unified Discount Function API with merchant settings and fixtures; three-year horizon.
What the Sticker Price Hides
On the buy path
- — Discounty prices by live discounted variants, so a catalog-wide campaign climbs from 150 variants on Lite to 1,000 on Essential and 10,000 on the top plan (verified Sep 2026)
- — Dealeasy prices by monthly orders, and a promotion month that clears 1,000 orders moves you to the Ultimate tier (verified Sep 2026)
- — A packaged app's rule shapes are the ceiling; the first exception marketing asks for is the moment the subscription stops being the answer
- — Two discount apps on one store means two functions deciding on the same lines, and combination behavior is governed by Shopify's discount-combination settings rather than by either vendor
On the build path
- — Custom apps that contain Function APIs are Plus-only, so the function stops being installable if the store ever leaves Plus
- — JavaScript functions reach the 11-million-instruction limit sooner than Rust on large carts, per Shopify's own language guidance
- — The legacy per-type Discount Function APIs are deprecated; any function written against them carries a migration to the unified API, and Shopify hasn't yet published the sunset date
- — ~$1,500–$5,000/yr in upkeep (Deploi estimate, illustrative)
What Merchants Say
The recurring pattern since Shopify Scripts stopped executing on 2026-06-30: a Plus merchant discovers a Ruby-era discount rule has no packaged equivalent and learns the replacement is a function in a custom app, not a settings screen.
Discount app reviews fall into the same trough: the campaign works until it has to combine with another discount or exclude one customer group, and the answer from support is that the rule shape isn't supported.
If You Change Your Mind Later
If you bought and outgrow it
Document every campaign's thresholds and exclusions before you cancel, because the configuration lives in the vendor's admin and the discounts a packaged app created stop when the app is removed. Native discounts you created yourself in Shopify admin are unaffected, so anything that can live there should.
If you built and want out
Nothing strands. The rule's configuration sits in metafields on your own products and customers, the function source is in your repository, and exit means uninstalling your own custom app. A retreat to a packaged app is a $9–$49.9/month decision (verified Sep 2026), not a migration.
When This Answer Changes
We're watching for:
- ▸ Shopify publishing a sunset date for the legacy per-type Discount Function APIs (Order, Product and Shipping), which sets the migration deadline for any function written against them
- ▸ Network access for functions leaving Shopify-enabled status or arriving on development stores, which would change how external data reaches a discount rule
- ▸ The native discount engine adding computed or metafield-driven conditions, which would move part of the build lane to WAIT
Verdict change log:
No changes since first publication (September 2026).
Common Questions
Do I need Shopify Plus to build a custom discount function?
Yes, a custom discount function needs Shopify Plus. Shopify's docs state that only stores on a Shopify Plus plan can use custom apps that contain Shopify Function APIs, and a custom discount function ships inside a custom app. Stores on any plan can use public App Store apps that contain functions, which is why Discounty, Dealeasy and the free SMART Functions Creator are the lane below Plus (verified Sep 2026).
Which Discount Function API should a new build target?
A new discount function targets the unified Discount Function API. The legacy per-type Order, Product and Shipping Discount APIs are deprecated, and Shopify's former order-discounts reference now redirects to the unified page's migration section. One store activates at most 25 discount functions, so consolidate rules into fewer configurable functions. The fetch network target is limited to custom apps installed on Shopify Plus and Enterprise stores (verified Sep 2026).
What does a custom discount function cost to build?
A custom discount function costs $8,000–$25,000 one-time, plus roughly 15–20% of build cost per year in upkeep (Deploi estimate, illustrative). The scope is one function on the unified Discount Function API, an input query over your own metafields, merchant-facing settings for thresholds, fixture tests and deployment. Expect 3–6 weeks. A packaged app that expresses the same rule runs $9–$49.9/month instead (verified Sep 2026).
Your Next Steps
If you're going with BUILD(matches your selected profile)
- Write the rule as a table of inputs and outputs marketing signs off on, including what happens when it meets another discount
- Try the free SMART Functions Creator against that table first; if it expresses the rule, stop here
- Design the input query and the reserved app-owned metafield namespace, and check the 3,000-byte and cost-30 limits before coding
- Build one function on the unified Discount Function API with function settings for every threshold marketing will want to change
- Test with function run against fixture carts, then replay logged production inputs before release
If you're going with BUY
- Match your billing driver to the app: Discounty bills by live discounted variants, Dealeasy by monthly orders (verified Sep 2026)
- Set discount-combination rules in Shopify admin before launch, so two discounts never stack by accident
- Confirm the app's discounts behave on POS if you sell in store
- Diary a re-check when marketing asks for the first rule shape the app can't express
Official Docs & Sources
- Discount Function API and migration from legacy APIs — shopify.dev
- Shopify Functions overview and plan gate — shopify.dev
- Function limits — shopify.dev
Official documentation linked for verification — our verdicts and estimates are our own.
Related Decisions
Should You Build or Buy B2B Tiered & Volume Pricing on Shopify?
Building B2B tiered pricing as a Function over native catalogs wins for mid-market wholesale; wait if three catalogs cover you.
Should You Build or Buy BOGO Automation on Shopify?
Building BOGO logic on Shopify Functions wins once your offers outgrow native Buy X Get Y discounts.
Should You Build or Buy Discount Stacking Rules on Shopify?
Customizing wins for discount stacking on Shopify: native combinations cover the common matrix, and a Functions policy layer protects the margin.
Build or Buy Bulk Discount Code Generation on Shopify?
Bulk discount code generation is the cleanest BUILD in the discounts stack: a one-time script replaces a subscription that wraps the same API.
Should You Build or Buy Your Shopify Scripts-to-Functions Migration?
A Scripts-to-Functions migration is a build for any store whose checkout logic still earns money — unported rules have already gone silent.
Ready to ship the discount rule no app expresses?
First we check whether a packaged app or the free no-code builder already covers your rule, because that saves you a build. When it doesn't, we scope one configurable function on the unified Discount Function API, put the data in metafields you own, and leave your marketing team settings they can change without a developer.
Contact us todayVerdict scored for the reference scenario above. Estimates are not quotes; app pricing carries its verification date and gets re-verified quarterly. Platform limits quoted from shopify.dev as of September 2026. Full scoring anchors: see the TCC methodology.
Read how we score these decisions (the TCC Framework). No affiliate links, no paid placement — no app vendor pays to appear here.