Should You Build Payment Rules for Pre-Order and TBYB?
Payment rules for pre-order and try-before-you-buy are a BUY: PreProduct and Downpay ship deposits, pay-later and charge-on-fulfillment flows from free to $259.99/month (verified Sep 2026). Add a payment customization function, which is Plus-only, when methods must be hidden or renamed per order type. The Payment Customization Function does not support subscriptions, so a subscription checkout needs a subscriptions app instead.
Your profile — see how the verdict shifts
- Confidence
- High — The carve-out is the load-bearing fact and it is documented, not inferred: the Payment Customization Function does not support subscriptions, because Shopify documents payment terms as incompatible with subscriptions. A merchant selling pre-orders and subscriptions through the same store therefore needs two mechanisms, and the function covers only one of them. Function APIs are Plus-gated on the custom lane: Shopify states that only stores on a Shopify Plus plan can use custom apps that contain Shopify Function APIs, while stores on any plan can use public App Store apps that contain functions. The documented limits, re-read on 2026-09-05, are a 256 kB compiled binary, 10,000 kB runtime linear memory, 512 kB stack memory, 11 million instructions for carts up to 200 line items, 128 kB input and 20 kB output, with input queries capped at 3,000 bytes and a calculated cost of 30. On the buy side both listings were read the same day: PreProduct at 4.9★ over 106 reviews and Downpay at 5.0★ over 92 reviews and Built for Shopify. Both ship the pre-order and deposit mechanics as a product; neither gates payment methods, which is the job the function actually does.
- Reference scenario
- $20M–$100M GMV · Shopify Plus · pre-order drops and try-before-you-buy alongside a subscription line · agency or in-house dev bench
- As of
- September 2026
Decision at a Glance
| Your profile | Verdict | Why |
|---|---|---|
| Pre-order only, no subscriptions | BUY | PreProduct or Downpay covers the whole flow, from deposit through balance capture, with a customer portal you would otherwise build. Nothing here needs a function. |
| Pre-order plus deposits on high-ticket items | BUY | Downpay prices by total order value processed, so a high-ticket program is the case where tier limits matter more than features. Read the caps before the feature list. |
| Pre-order and subscriptions in one catalog | CUSTOMIZE | The function cannot reach the subscription checkout, so you buy the pre-order app, keep a subscriptions app for selling plans, and gate methods with a function only on the carts it can see. |
| Gating rules no condition list expresses | BUILD | A rule computed from cart contents, customer tags and metafields is exactly what a payment customization function is for, and it requires Plus. |
What Payment Customization for Pre-Order & TBYB Actually Drives
| Outcome | Impact | How it works |
|---|---|---|
| Revenue — direct | High | Pre-order and deposit flows capture demand before stock lands, turning a sold-out product page into a real order with a payment mandate attached to it. |
| Customer experience | High | Showing only the payment methods that survive a deferred charge stops a shopper choosing a method that fails silently at capture weeks later. |
| Operational efficiency | Medium | Charging on fulfillment instead of at order time removes the manual capture queue finance runs through after every pre-order batch. |
| Revenue — indirect | Medium | A try-before-you-buy flow lowers the first-purchase barrier on high-consideration items, lifting the rate at which browsers become customers at all. |
| Data & insight | Low | Payment gating produces little insight by itself; the useful signal is the pre-order demand curve, and it accumulates inside the app. |
Spend ceiling: Pre-order mechanics are a packaged product priced like one, and rebuilding them buys nothing. Reserve custom spend for the gating rule no condition list expresses, and set aside a separate budget line for the subscription checkout the function cannot reach. Two mechanisms is the floor for a mixed catalog, not a sign that something went wrong.
What buying enables (top apps)
- + Pre-order, deposit, pay-later and charge-on-fulfillment flows with customer portals and stored payment mandates, live within days
- + Deposit collection wired to product-page blocks and Shopify Flow, so finance sees balance-due state without maintaining a spreadsheet
- + Commission and tier models that scale with pre-order volume, so a small program costs almost nothing to run for a season
What building additionally unlocks
- + Payment methods hidden, reordered or renamed from a rule computed over cart contents, customer tags and metafields, which no condition list expresses
- + One rule set covering pre-order, try-before-you-buy and standard carts, versioned in your repository instead of split across vendor dashboards
- + Merchant settings your operations team edits directly, so a country list or a cart-total ceiling changes without a deployment
Find Your Verdict in 3 Questions
Does the checkout need deposits, pay-later or try-before-you-buy mechanics?
Yes: Go to question 2.
No: Your verdict: BUILD — with no pre-order mechanics to buy, the remaining job is method gating, which a Plus-only payment customization function does.
Does a packaged app cover the flow, including your charge timing and customer portal?
Yes: Go to question 3.
No: Your verdict: BUILD — the flow is custom, and pre-order state plus a payment customization function is a Plus-only build at $8,000–$22,000 (Deploi estimate, illustrative).
Do you also sell subscriptions through the same store?
Yes: Your verdict: CUSTOMIZE — buy the pre-order app and solve the subscription checkout separately, because the Payment Customization Function does not support subscriptions.
No: Your verdict: BUY — PreProduct or Downpay covers the flow from free to $259.99/month (verified Sep 2026).
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 | Both apps install and configure in a day; a function is a custom app, a deployment pipeline and a merchant settings form. | ||
| Recurring fees | PreProduct runs free to install plus 5.0% of pre-order revenue up to $259.99/month, and Downpay $29–$249/month (verified Sep 2026); a function bills nothing. | ||
| Maintenance & upgrades | The vendors absorb checkout and API changes; your function needs quarterly API version bumps and a fixture run before each release. | ||
| Switching & exit | Pre-order state and stored payment mandates live in the vendor's data model; a payment customization function holds no state at all. | ||
| Risk | |||
| Vendor risk | PreProduct shows 4.9★ over 106 reviews and Downpay 5.0★ over 92 with Built for Shopify status: healthy, not enormous, review bases. | ||
| Security & compliance surface | A deposit app stores payment mandates and charges them later; a payment customization function never sees a card number. | ||
| Platform-deprecation exposure | Both ride checkout extensibility and Functions, which Shopify versions on a published cadence; the subscription exclusion is a documented boundary rather than a defect. | ||
| Value | |||
| Fit to requirement | Apps cover pre-order and deposits end to end; only a function expresses a gating rule computed over cart, customer and metafield data. | ||
| Time to market | A drop goes live this week on either app, against 2–5 weeks for a function with settings and fixtures (Deploi estimate, illustrative). | ||
| Performance & scale | Function budgets are hard and published: 11 million instructions for carts up to 200 line items, 128 kB input and a 20 kB output cap. | ||
| Data ownership & AI-readiness | Pre-order demand signal accumulates inside the app; a function reads your own metafields and leaves every record where it started. | ||
| Focus & opportunity cost | Pre-order mechanics are a solved category, so a sprint spent rebuilding them buys nothing a customer can see. | ||
The App Landscape
| App | Status | Pricing | Best for |
|---|---|---|---|
| PreProduct next-gen pre-order | Live — 4.9★, 106 reviews; 7-day trial on paid tiers. Pre-orders charged upfront, later or by deposit, with customer portals and unlimited listings; the free Starter tier takes 5.0% of paid pre-order revenue, Growth 0.5%, and Scale removes commission up to $5k a month in pre-order revenue (verified Sep 2026). Scale Plus is recommended for Shopify Plus stores. | Starter free plus 5.0% of paid pre-order revenue; Growth $29.99/month plus 0.5% (or $329.99/year); Scale $59.99/month (or $659.99/year); Scale Plus $259.99/month (or $2,849.99/year) (verified Sep 2026) | Pre-order programs where charge timing and a customer portal matter more than payment-method gating |
| Downpay: Partial Pay & Deposit | Live — 5.0★, 84 reviews, Built for Shopify. The highest published ceiling of the three, and the only one exposing API access, sandbox and beta features on its top plan, which matters if the deposit flow has to talk to an ERP or a custom quoting process. | Essentials $29/month up to $5,000 order value with product-page block, buy button, stored card and bulk balance collection, Standard $49/month up to $10,000, Pro $99/month up to $25,000, Scale $249/month up to $100,000 with API access, with a 7-day trial (verified Sep 2026) | Deposit and balance-due flows on high-ticket or made-to-order items |
| Subscription checkout (separate app category) | Category — The category the payment customization function cannot reach, and the reason this page exists. Shopify Subscriptions, Recharge and Loop run their own selling-plan checkout; the function does not support subscriptions, so no amount of rule-writing brings that checkout under the same logic. The same boundary appears in cart transform, where Shopify rejects lineExpand, linesMerge and lineUpdate operations whenever a selling plan is present. Plan two payment paths from the first sprint. | Priced separately from this decision; confirm the current listing before you model it | The subscription half of a mixed catalog, which needs its own checkout design |
| Custom payment customization function (custom app) | Build lane — The same hide, move and rename operations the apps perform, driven by an input query you write over cart, customer, delivery address and metafields. Installable only on Shopify Plus, because custom apps containing Function APIs are Plus-only. Worth it for a computed rule no condition list expresses, and for nothing else. | $6,000–$18,000 one-time plus upkeep (Deploi estimate, illustrative) | Plus merchants whose gating rule is a computation rather than a condition list |
The Build Path
- Express the gating rule as hide, move and rename operations: A payment customization function receives the cart, the customer and the available payment methods, then returns operations that hide, reorder or rename them. Write the rule as a decision table first: which method, under which combination of order type, value, customer tag and metafield. Deposits, terms and charge timing are not operations it can return.
- Keep the input query inside the documented ceilings: Input queries are capped at 3,000 bytes excluding comments and a calculated cost of 30, list arguments cannot exceed 100 elements, and metafield values over 10,000 bytes are not returned. A pre-order tier or a risk score belongs in a metafield written ahead of checkout, not derived inside the function on every cart.
- Route subscriptions somewhere else on purpose: The function does not support subscriptions, and a selling plan on the cart is also what makes Shopify reject cart transform operations. Design the subscription checkout as a separate path on day one, owned by the subscriptions app, and keep the function's rules scoped to carts it can actually see.
- Test with fixtures, then replay production input: The budget is 11 million instructions for carts up to 200 line items, a 256 kB compiled binary, 128 kB of input and 20 kB of output. Run the function against fixture carts covering pre-order, TBYB, mixed and subscription cases with the CLI, then replay logged production input before release.
- Effort band
- $8,000–$22,000 for one production payment customization function with settings and fixtures — Deploi estimate (illustrative); lands in the $10–25K contact-form band
- Typical timeline
- 2–5 weeks to a production function (Deploi estimate, illustrative)
- Maintenance, honestly
- ~15–20% of build cost per year (Deploi estimate): roughly $1,200–$4,400/yr (Deploi estimate, illustrative) for quarterly API version bumps, checkout changes and the threshold edits operations asks for.
- What you own — and what you take on
- You own: the rule, its thresholds in your metafields and settings, the fixtures and the deployment history. You take on: API version upkeep, a Plus dependency, and a subscription checkout that stays outside the function's reach permanently.
3-Year Total Cost of Capability
| Buy (app path) | Build (custom path) | |
|---|---|---|
| Year 0 (setup) | $0–$500 | $8,000–$22,000 |
| Years 1–3 (recurring) | $1,080–$8,964 | $3,600–$13,200 (maintenance) |
| 3-year total | ≈$1,080–$9,464 | ≈$11,600–$35,200 |
- † All figures illustrative samples for the reference scenario — not quotes, not verified pricing.
- † Left column is one pre-order or deposit app at a mid tier, held flat; commission on pre-order revenue is excluded, which is conservative for the build case.
- † Right column is a custom payment customization function with merchant settings and fixtures; the subscriptions app both lanes still need is excluded from both columns; three-year horizon.
What the Sticker Price Hides
On the buy path
- — PreProduct's Starter is free to install and takes 5.0% of paid pre-order revenue, so a large drop costs more than any flat tier (verified Sep 2026)
- — Downpay's tiers cap total order value processed, from $5,000 on Essentials to $100,000 on Scale, so a strong quarter moves the bill (verified Sep 2026)
- — Neither app hides or renames payment methods, so gating a method for pre-order carts stays a separate mechanism you configure
- — Outstanding deposits and stored payment mandates sit in the vendor's data model, which is what an exit actually costs you
On the build path
- — The Payment Customization Function does not support subscriptions, so a mixed catalog needs a second mechanism no matter how good the function is
- — Custom apps containing Shopify Function APIs are Plus-only, so the build assumes a plan you keep paying for
- — Input query limits bite early: 3,000 bytes, a calculated cost of 30, list arguments capped at 100 elements, and metafields over 10,000 bytes not returned
- — ~$1,200–$4,400/yr upkeep (Deploi estimate, illustrative)
What Merchants Say
Dev teams describe finding the subscription carve-out mid-build: the function gated pre-order carts exactly as designed, and had nothing to say about the subscription checkout running beside it.
The recurring complaint about pre-order apps is charge timing rather than features: a deposit taken at order, a balance captured weeks later, and finance reconciling both by hand.
If You Change Your Mind Later
If you bought and outgrow it
Leaving a pre-order app stops the flow and leaves the state behind: open deposits, stored payment mandates and unfulfilled pre-orders sit in the vendor's model. Run the open book down before you uninstall, and confirm what the export includes while you are still a paying customer.
If you built and want out
A payment customization function holds no state, so removing it restores Shopify's default payment method list on the next checkout and strands nothing. What you keep is the rule itself, versioned in your repository and redeployable. The Plus dependency is the only real tie, since the custom app stops installing without it.
When This Answer Changes
We're watching for:
- ▸ Shopify extending payment customization to subscription checkouts, which would remove the carve-out this whole decision is built around
- ▸ PreProduct or Downpay changing commission rates or order-value caps, since both price on volume rather than on features
- ▸ Checkout extensibility changes that alter which payment surfaces a function can read or modify
Verdict change log:
No changes since first publication (September 2026).
Common Questions
Does the Payment Customization Function work with subscriptions?
No. The Payment Customization Function does not support subscriptions, which Shopify documents as payment terms being incompatible with subscriptions. A subscription checkout needs its own mechanism, normally a subscriptions app's selling-plan flow. Budget 2 payment paths rather than 1: the pre-order flow the function gates, and the subscription flow it cannot reach. Shopify rejects cart transform operations on selling-plan carts for the same structural reason.
Do we need Shopify Plus to build a payment customization function?
Yes. Shopify states that only stores on a Shopify Plus plan can use custom apps containing Shopify Function APIs. Stores on any plan can use public apps distributed through the App Store that contain functions. A custom payment customization function is therefore a Plus build, running inside hard budgets: 11 million instructions for carts up to 200 line items, and a 20 kB output cap.
What does a payment customization function cost to build?
A payment customization function costs $8,000–$22,000 one-time, plus roughly 15–20% of build cost per year in upkeep (Deploi estimate, illustrative), over 2–5 weeks. The scope covers the rule, an input query inside the 3,000-byte ceiling, merchant settings and fixture tests. PreProduct and Downpay cover the pre-order and deposit mechanics from free to $259.99/month (verified Sep 2026), so the build pays only for gating logic no app expresses.
Your Next Steps
If you're going with BUY(matches your selected profile)
- List every order type you sell: standard, pre-order, deposit, try-before-you-buy and subscription, and mark which app owns each
- Match the tier to volume, not features: PreProduct prices on pre-order revenue and Downpay on total order value processed
- Confirm charge timing end to end, from deposit to balance capture, against how finance actually reconciles
- Check whether any payment method has to be hidden for deferred-charge orders, since neither app does that
- Design the subscription checkout as a separate path before launch, because the payment customization function will not reach it
If you're going with BUILD
- Write the gating rule as a decision table and check whether a condition list already expresses it
- Precompute customer tier and order type into metafields, keeping the input query under 3,000 bytes
- Expose thresholds through function settings so operations can edit a country list without a deployment
- Build fixture carts for pre-order, TBYB, mixed and subscription cases, then replay logged production input
- Confirm Plus stays in the plan, since a custom app containing a function will not install without it
Official Docs & Sources
- Payment customizations — 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
Cart Transform vs. a Bundle App: Who Owns Pricing?
Overriding a bundle line's price, title and image with Cart Transform's lineUpdate works only on development stores or Shopify Plus; bundle apps cover the rest.
Should You Run a Custom Cart Transform Alongside an App's?
Shopify caps cart transform functions at one per app rather than one per store, and runs every app's function, so a custom one can sit beside a bundle app's.
Branding API vs. the Free Checkout Editor: Do You Need Code?
The free checkout and accounts editor covers most branding on every plan; Plus API overrides add precision, and the Checkout Blocks branding editor ends 2026-12-31.
Checkout Extension Network Access: What Shopify Actually Allows
Checkout UI extensions declare four capabilities in the extension TOML file, and network_access is the one Shopify makes you request before publishing.
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.
Selling pre-orders and subscriptions from one store?
We map the two checkout paths before anyone writes a function: what the pre-order app owns, what a payment customization function can gate, and where the subscription flow has to go instead.
Contact us todayVerdict scored for the reference scenario above. Estimates are not quotes; app pricing carries its verification date and gets re-verified quarterly. 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.