Merchant-Editable Checkout Rules: Flow, Functions, or Both?
Merchant-editable checkout rules are a CUSTOMIZE on Shopify Plus: Flow writes the value into a metafield, and a Function reads that metafield during checkout. Shopify's own docs say fetching data from metafields during checkout is more efficient because it avoids an external network call. Only Plus stores can use custom apps containing Function APIs, and the Function build runs $12,000–$35,000 (Deploi estimate, illustrative).
Your profile — see how the verdict shifts
- Confidence
- Medium — Each half of this pattern is documented; the join between them is our synthesis, which is why confidence sits at Medium rather than High. Read Shopify's Flow metafields page: workflows can get or set metafield and metaobject data, with native update actions for collection, company, company location, customer, order, product, product variant and shop metafields (verified Sep 2026). Read the Functions network-access page: network access has to be enabled by Shopify and is not available on dev stores or in a feature preview, and fetching data from metafields during checkout is more efficient because it avoids an external network call. Read the Functions overview: 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 containing functions. Shopify publishes no single page prescribing the combined pattern, so the architecture recommendation here is ours, built from those three sources. The App Store side is thin for this specific problem: MESA is a genuine workflow-automation platform at 5.0★ across 153 reviews, but it runs after events like Flow does and not inside checkout, so the closest bought lane is the checkout-rule app category rather than any single product. Build bands are Deploi estimates.
- Reference scenario
- $20M–$200M GMV · Shopify Plus · a merchandising team that changes rule thresholds weekly · one custom validation or discount Function · agency dev bench with no deploy window on demand
- As of
- September 2026
Decision at a Glance
| Your profile | Verdict | Why |
|---|---|---|
| Basic, Grow or Advanced plan | BUY | Only stores on a Shopify Plus plan can use custom apps that contain Shopify Function APIs, so the build lane does not exist here. Stores on any plan can use public App Store apps containing functions, which is the whole checkout-time option below Plus. Flow still runs free for everything after the order exists. |
| Plus, the rule is set once and rarely changes | BUILD | Skip the indirection. A threshold that moves twice a year belongs in the Function's own logic, where there is no metafield to keep in sync and no workflow to debug when the value looks wrong. |
| Plus, merchandising changes the rule weekly | CUSTOMIZE | The reference scenario. Flow writes the new value into a metafield on a schedule or off an event, and the Function reads it at the next checkout with no deploy and no network call. Merchandising edits a number; engineering ships nothing. |
| Plus, thousands of per-variant rules changing through the day | BUILD | Flow is the wrong writer at this size: Get data actions run on lists of up to 100 items and the Scheduled trigger fires at most once every 10 minutes. Write the metafields from a bulk job against the Admin API instead, and keep the Function reading exactly as before. |
What Flow + Function Pattern Actually Drives
| Outcome | Impact | How it works |
|---|---|---|
| Operational efficiency | High | Merchandising changes a threshold in a metafield instead of filing a ticket and waiting for a release, which removes engineering from every routine policy change. |
| Revenue — direct | High | Checkout rules decide what a cart is allowed to buy, stack or pay, so a rule that lags a week behind the merchandising calendar sells at the wrong price or blocks the wrong order. |
| Customer experience | Medium | A rule enforced by a Function during checkout gives the shopper one consistent answer, where theme-level messaging can promise something the payment step then refuses. |
| Data & insight | Medium | The rule's current value sits in a metafield that reporting, the ERP and any other app can read through the Admin API, where a value compiled into a Function is visible only in source control. |
Spend ceiling: Size the spend to how often the rule changes and how specific it is. A fixed threshold nobody edits does not justify the pattern at all. A policy that moves weekly and that no settings screen expresses is worth the $12,000–$35,000 build (Deploi estimate, illustrative), because the recurring saving is a deploy cycle per change rather than a subscription.
What buying enables (top apps)
- + A working checkout rule the same day, with a settings screen non-technical staff already understand
- + Availability on every plan, since stores on any plan can use public App Store apps containing functions
- + Vendor-maintained compatibility with Shopify's quarterly Function API versions
- + A cheap way to prove the rule is worth enforcing before funding a build
What building additionally unlocks
- + A rule that matches your written policy exactly, rather than the nearest option on a vendor's settings screen
- + Threshold changes without a deploy, because the value lives in a metafield Flow keeps current
- + A checkout-time read with no external network call, which Shopify documents as the more efficient path
- + Rule values queryable through the Admin API by reporting, the ERP and anything else you run
Find Your Verdict in 3 Questions
Does the rule have to be enforced while the checkout is in progress, rather than after the order exists?
Yes: Go to question 2.
No: Your verdict: WAIT — Flow alone covers everything downstream of an event, free on every plan from Basic upward, with no Function required.
Are you on Shopify Plus?
Yes: Go to question 3.
No: Your verdict: BUY — custom apps containing Shopify Function APIs are Plus-only, so a public App Store app containing a function is the only checkout-time lane.
Does anyone outside engineering need to change the rule's value between deploys?
Yes: Your verdict: CUSTOMIZE — Flow writes the metafield, the Function reads it at checkout, and the threshold changes without a release at $12,000–$35,000 for the build (Deploi estimate, illustrative).
No: Your verdict: BUILD — put the value in the Function's own logic and skip the metafield indirection, along with the second thing to debug.
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 | A checkout-rule app installs and configures in an afternoon; a custom Function plus the Flow workflow that feeds it is a 4–8 week build at $12,000–$35,000 (Deploi estimate, illustrative). | ||
| Recurring fees | Rule apps bill monthly for as long as the rule exists; the Flow half is free on every plan from Basic upward and a Function you own carries no subscription line at all. | ||
| Maintenance & upgrades | The app vendor absorbs Shopify's quarterly Function API version changes; your team absorbs them for a custom Function, along with the metafield definition the workflow writes into. | ||
| Switching & exit | Uninstalling a rule app takes its logic and its stored settings with it; the Flow and Function lane leaves the rule values sitting in metafields, readable through the Admin API by whatever replaces the Function. | ||
| Risk | |||
| Vendor risk | A rule app in the checkout path is a vendor whose outage is your outage; a Function you own runs on Shopify's own infrastructure with no third party in the decision. | ||
| Security & compliance surface | The pattern moves no data off-platform: the metafield lives in Shopify and the Function reads it during checkout without an external network call, which is the safest shape a checkout rule can take. | ||
| Platform-deprecation exposure | Both lanes ride the Function APIs and their version cadence. Metafields and Flow's update actions are stable primitives, so the moving part is the Function's input query rather than the storage underneath it. | ||
| Value | |||
| Fit to requirement | A rule app covers the rules its developer chose to expose, and the one you need next quarter is a feature request; a Function reading your own metafield encodes the exact policy your merchandising team writes down. | ||
| Time to market | Same day against 4–8 weeks (Deploi estimate, illustrative), and the app path lets you prove the rule is worth enforcing before funding a build. | ||
| Performance & scale | Shopify states that fetching data from metafields during checkout is more efficient because it avoids an external network call, and Function network access has to be enabled by Shopify anyway, so the metafield read is both faster and available today. | ||
| Data ownership & AI-readiness | Rule settings inside a vendor's app are invisible to your warehouse; the same rule as a metafield is queryable through the Admin API by every other system you run, including reporting. | ||
| Focus & opportunity cost | Two moving parts mean two things to debug, so the pattern earns its keep only where the rule genuinely changes between deploys. | ||
The App Landscape
| App | Status | Pricing | Best for |
|---|---|---|---|
| Shopify Flow | Native — Per july 2026 research. Shopify's own automation layer — the WAIT option to exhaust first | Free at entry volumes; scales with volume (verified Sep 2026) | Writing the rule value that a Function reads a moment later at checkout |
| MESA: Workflow Automation | Live — 5.0★, 153 reviews; 7-day trial on all paid plans. A multi-step automation platform that reaches further across your stack than Flow's own actions. Useful for orchestrating a bulk job's surrounding steps, though it is an automation tool rather than a bulk-editing one, so it does not remove the need for a real bulk lane. | Basic $12/month; Flex $29/month; Pro $99/month; Unlimited $299/month (verified Sep 2026) | The writer half when the rule value comes from tools Flow's own actions cannot reach |
| Checkout rule and validation apps | Category — Public App Store apps containing Shopify Functions, which stores on any plan can install. The category covers common, well-shaped rules with a settings screen: order minimums and maximums, quantity caps, address blocklists, and hiding payment or delivery options. It does not cover a rule whose value is produced by an event your automation already processed, and each app's rule vocabulary is fixed by its developer rather than by your policy. | Varies by vendor; confirm on the current listing | Below Plus, and anywhere a vendor's settings already match your policy exactly |
| Custom Function reading a Flow-written metafield | Build lane — A custom app containing a validation, discount or delivery Function whose input query reads a metafield that Flow keeps current. Plus only, because only stores on a Shopify Plus plan can use custom apps that contain Shopify Function APIs. The Flow half is free and needs no code. | $12,000–$35,000 one-time plus ~15–20% a year in upkeep (Deploi estimate, illustrative) | Plus merchants whose checkout policy is specific and whose ops team changes it between deploys |
The Build Path
- Flow writes, the Function reads: Flow updates a metafield on the resource the rule varies by, and the Function's input query reads that metafield during checkout. Shopify states the metafield read is more efficient than an external network call, and Function network access has to be enabled by Shopify in any case, so this is the available shape as well as the fast one.
- Pick the narrowest resource the rule actually varies by: Flow ships update actions for collection, company, company location, customer, order, product, product variant and shop metafields. A shop-level metafield holds one global threshold; a customer or company metafield carries per-account policy; a variant metafield fans out to thousands of rows and needs a bulk writer instead of Flow.
- Plan the namespace and the write path together: Shopify recommends a reserved prefix in the metafield namespace so other apps cannot use your metafields, and illustrates it with an app-scoped prefix. A metafield Flow writes has to sit somewhere Flow can write, so decide the namespace, the definition and the writer in one design pass rather than discovering the conflict during build.
- Validate the value, and test the Function against real inputs: A missing or malformed metafield surfaces as a Function runtime error, not a friendly message: Shopify documents twelve error types including InvalidInputQueryError, InvalidVariableValueError and InstructionCountLimitExceededError. Use the CLI to run the Function against a known JSON input and to replay a previously logged execution before the rule reaches a live cart.
- Effort band
- $12,000–$35,000 build — Deploi estimate (illustrative); a single-rule Function with one Flow workflow sits in the $10–25K contact-form band, a multi-rule Function with per-variant fan-out in the $25–75K band
- Typical timeline
- 4–8 weeks (Deploi estimate, illustrative); the Flow half is usually done in a day, and the Function's edge cases take the rest
- Maintenance, honestly
- ~15–20% of build cost per year (Deploi estimate): roughly $1,800–$7,000/yr (Deploi estimate, illustrative) for Function API version bumps, metafield definition changes and new rule shapes the merchandising team asks for. Flow itself stays free.
- What you own — and what you take on
- You own: the rule's logic, the metafield definition, the value's history and the ability to change the threshold without a deploy. You take on: two moving parts to debug, and a Function that has to behave sensibly when the metafield is empty.
3-Year Total Cost of Capability
| Buy (app path) | Build (custom path) | |
|---|---|---|
| Year 0 (setup) | $1,500–$6,000 (configuration and testing) | $12,000–$35,000 |
| Years 1–3 (recurring) | $2,900–$10,800 (subscription plus changes) | $5,400–$21,000 (maintenance) |
| 3-year total | ≈$4,400–$16,800 | ≈$17,400–$56,000 |
- † All figures illustrative samples for the reference scenario — not quotes, not verified pricing.
- † Buy path: one checkout-rule app on a mid tier plus initial configuration at illustrative agency rates; the app is assumed to cover the policy as written, which is the optimistic case.
- † Build path: one Function with a Flow workflow writing a single metafield, plus upkeep; three-year horizon; Flow is free in both lanes.
What the Sticker Price Hides
On the buy path
- — A rule app covers its developer's rule vocabulary, not your policy, and the gap only appears once the policy changes
- — Rule settings live inside the vendor's app, so your warehouse and your reporting cannot see what the rule was last month
- — An app in the checkout path makes the vendor's uptime part of your conversion rate
- — Uninstalling takes the stored configuration with it, so the migration is a re-entry job rather than an export
On the build path
- — Two moving parts mean two failure modes: the Function can be perfect while the workflow that feeds it quietly stops writing
- — A missing or malformed metafield surfaces as a Function runtime error rather than a friendly message, so the empty case needs designing on purpose
- — Flow's Get data actions run on lists of up to 100 items, so per-variant fan-out needs a bulk writer rather than a loop
- — ~$1,800–$7,000/yr upkeep (Deploi estimate, illustrative) for Function API version bumps and new rule shapes
What Merchants Say
Merchandising teams describe the same loop: a threshold needs one number changed, and the change waits on a deploy window because the number lives inside compiled logic.
Rule-app reviews cluster at the edge of the settings screen: the app covers the rule you have today, and the one you need next quarter is a feature request with no date.
If You Change Your Mind Later
If you bought and outgrow it
Removing a rule app takes its logic and its stored settings with it, and checkout reverts to Shopify's defaults the moment it uninstalls. Screenshot or export every rule configuration while the app is still live, because re-entering settings from memory is how a policy quietly changes during a migration.
If you built and want out
Very little strands: the rule values stay in metafields that any future Function, app or reporting query can read through the Admin API. Retiring the Function leaves the data behind rather than deleting it, and the Flow workflow that writes the value keeps working whether or not anything reads it.
When This Answer Changes
We're watching for:
- ▸ Function network access opening beyond Shopify-enabled gating, which would widen where rule data can come from (still enabled by Shopify only, and unavailable on dev stores or in a feature preview, as of September 2026)
- ▸ Any change to the Plus gate on custom apps containing Shopify Function APIs
- ▸ Flow's Get data cap rising above 100 items, which would let one workflow fan a rule out across a larger catalog
Verdict change log:
No changes since first publication (September 2026).
Common Questions
Can Shopify Flow run logic inside checkout?
No. Flow runs after an event has happened, so it cannot decide anything while a checkout is in progress. A Function does that job. The working pattern is a handoff. Flow writes the value with one of its 8 native metafield update actions, covering collections, companies, company locations, customers, orders, products, variants and the shop. The Function then reads that metafield during checkout.
Do I need Shopify Plus to combine Flow and Functions?
For a custom Function, yes. 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. Shopify Flow itself stays free on Basic, Grow, Advanced and Plus, so a store below Plus gets the writer half at no cost and buys the checkout half. A custom Function build runs $12,000–$35,000 (Deploi estimate, illustrative).
How does a Shopify Function use data from outside Shopify?
Through a metafield that Flow already filled. Network access for functions has to be enabled by Shopify and is not available on dev stores or in a feature preview. Flow's Send HTTP Request action fetches the outside value on Grow, Advanced and Plus. The action waits up to 30 seconds for a response and retries for up to 24 hours, and then an update action stores the value in a metafield.
Your Next Steps
If you're going with CUSTOMIZE(matches your selected profile)
- Write the policy down as a sentence with one number in it, then decide which resource that number varies by
- Define the metafield and its namespace with the write path in mind, since Flow has to be able to write it
- Build the Function to read the metafield through its input query and to behave sensibly when the value is missing
- Wire the Flow workflow that keeps the value current, off an event where possible and a schedule where not
- Test with the CLI against a known JSON input and a replayed execution before the rule reaches a live cart
If you're going with BUY
- Write the policy down first, then check it against a rule app's settings screen rather than its marketing copy
- Confirm the app is a public App Store app containing a function, which is what makes it work below Plus
- Export or screenshot the rule configuration once it is live, because uninstalling takes the settings with it
- Diary a re-decision the first time the policy needs a rule the settings screen cannot express
Official Docs & Sources
- Flow metafields: get and set metafield data in a workflow — Shopify Help Center
- Shopify Functions overview (Plus gate on custom apps) — shopify.dev
- Function network access and metafield reads at checkout — shopify.dev
Official documentation linked for verification — our verdicts and estimates are our own.
Related Decisions
Flow Loops or Bulk Operations for Hundreds of Shopify Records?
Flow's Get data actions run on lists of up to 100 items, so a For each loop cannot sweep a large catalog. Catalog-wide edits need a real bulk lane.
Your App Has No Flow Connector: Build the Bridge or Wait?
Only an app's own developer can ship its Flow tasks. Outbound automation needs just Send HTTP Request; inbound needs a bridge app from $29/month (verified Sep 2026).
Flow Failure Alerting on Shopify: Build the Watcher or Buy One?
Shopify ships no store-wide Flow alert. Build a watcher on the Workflow error occurred trigger, which fires once per workflow version within a 30-day window.
Flow Workflow Retries on Shopify: Build Your Own Safety Net?
Flow retries transient errors like step timeouts and 5XX statuses, and never retries permanent ones. Critical workflows need their own error branches.
Should You Build or Buy Site Search on Shopify?
Site search on Shopify splits by catalog size: native to ~1,000 SKUs, buy in the middle, build at big-catalog, search-led scale.
Want a checkout rule your merchandising team can edit?
We design the metafield, build the Function that reads it, and wire the Flow workflow that keeps it current, so the threshold changes without a deploy.
Contact us todayVerdict scored for the reference scenario above. Estimates are not quotes; app pricing and platform limits carry their verification date and get 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.