Should You Run a Custom Cart Transform Alongside an App's?
Running a custom cart transform alongside an app's is a CUSTOMIZE, because the cap is one cart transform function per app, not one per store. Shopify states that when a store has cart transform functions from more than one app, all of them run. Keep the bundle app, free to $149/month (verified Sep 2026), and build your own for the job it misses. Consolidate only when both would rewrite the same line.
Your profile — see how the verdict shifts
- Confidence
- High — Two separate rules decide this page, and Shopify's Cart Transform reference states both, re-read on 2026-09-05. First: you can install a maximum of one cart transform function per app on each store, which is a per-app cap and not a per-store one. Second: if a store has cart transform functions from more than one app, all of them run. Coexistence is therefore the documented default, and a custom app occupies its own slot beside a bundle app's. Two further restrictions sit on separate axes and are easy to conflate with the first two. Only development stores or stores on a Shopify Plus plan can use apps with lineUpdate operations, which is a store-type gate rather than a per-app one. And Shopify rejects lineExpand, linesMerge and lineUpdate operations if a selling plan is present, which applies on every plan including Plus. On the app side, the three live listings read the same day are FBP (5.0★, 3,063 reviews), Simple Bundles & Kits (4.9★, 786 reviews) and Zoorix (4.9★, 392 reviews), all Built for Shopify. One honest limit: none of the three listings states which cart transform operations its app runs, so collision analysis starts with a question to the vendor rather than a documentation page.
- Reference scenario
- $20M–$100M GMV · Shopify Plus · a bundle app already in production, plus a second cart-composition rule to build · agency or in-house dev bench
- As of
- September 2026
Decision at a Glance
| Your profile | Verdict | Why |
|---|---|---|
| One bundle app, no custom function yet | BUY | The app already covers catalog bundles, mix-and-match and single-line checkout. Writing a function to reproduce that buys nothing a shopper can see. |
| Bundle app plus a distinct custom rule | CUSTOMIZE | The per-app cap leaves your custom app its own slot, and Shopify runs both. Keep the vendor for catalog bundles and own the computed case yourself. |
| Two functions touching the same cart lines | BUILD | Shopify runs every app's function and documents no order between them, so a shared line is a design problem you own. One function has to be the authority. |
| Subscription lines in the cart | WAIT | Shopify rejects lineExpand, linesMerge and lineUpdate whenever a selling plan is present, on every plan including Plus. Neither lane works, so solve it in the subscription app. |
What Cart Transform Function Coexistence Actually Drives
| Outcome | Impact | How it works |
|---|---|---|
| Revenue — direct | High | A merged bundle line prices and presents a multi-component purchase as one item, which is what makes build-a-bundle and kit offers convert instead of confusing. |
| Customer experience | High | Cart and checkout show what the shopper believes they bought: one bundle line at one price, rather than five components and a discount to reconcile. |
| Operational efficiency | Medium | Keeping the app for catalog bundles and a function for the computed case avoids rebuilding merchandising tooling the team already knows how to run. |
| Revenue — indirect | Medium | Coexistence lets you test a new composition rule without removing the app that already earns, so the experiment costs a sprint instead of a quarter. |
| Data & insight | Low | Cart transform produces no reporting of its own, and bundle performance still comes out of order data in either lane. |
Spend ceiling: Coexistence itself is free; collision is what costs money. Spend on a second function only when the rule it encodes sits outside the app's schema, and budget the collision analysis before the build. Shopify runs every app's function and publishes no order between them, so the design work is the deliverable, not the code.
What buying enables (top apps)
- + Bundle catalogs, mix-and-match, volume breaks and single-line checkout maintained by a vendor, with free tiers that carry real order volume
- + Merchandising tooling in the same product as the bundle logic, including upsells, cross-sell placements and cart drawers
- + Vendor-side upkeep of Shopify API versions and checkout changes, which is the recurring work a custom function hands to your team
What building additionally unlocks
- + A second cart transform for a rule the app's schema has no field for, running beside the app rather than replacing it
- + Composition logic expressed as code you version and test, with fixture carts covering every overlap between your function and the app's
- + Bundle structure held in your own product metafields, so the definitions survive the day you change bundle vendors
- + Freedom to keep the app for catalog bundles while owning the computed cases, instead of picking one tool for both jobs
Find Your Verdict in 3 Questions
Can the cart contain a selling plan, meaning a subscription line?
Yes: Your verdict: WAIT — Shopify rejects lineExpand, linesMerge and lineUpdate operations when a selling plan is present, so neither lane works on that cart.
No: Go to question 2.
Would your rule and the app's rewrite the same cart lines?
Yes: Your verdict: BUILD — consolidate into one function you own, because Shopify runs every app's function and publishes no order between them.
No: Go to question 3.
Does your rule need to change a line's price, title or image?
Yes: Your verdict: CUSTOMIZE — keep the app and build the function on Plus, since lineUpdate requires a development store or a Shopify Plus plan.
No: Your verdict: CUSTOMIZE — keep the app and add a function using linesMerge and lineExpand, which runs alongside the app's own.
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 bundle app installs and configures in an afternoon; a cart transform function is a custom app, a pipeline and a set of collision tests. | ||
| Recurring fees | The three bundle apps run from free to $149/month (verified Sep 2026); a custom function adds no subscription line at all. | ||
| Maintenance & upgrades | The vendor absorbs API versions and checkout changes; your function needs version bumps plus a re-test whenever the app's behavior shifts. | ||
| Switching & exit | Bundle definitions live inside the app and leave with it; a function you own reads product metafields that stay in your store. | ||
| Risk | |||
| Vendor risk | Review bases here are healthy at 3,063, 786 and 392, and all three carry Built for Shopify status; a function you own has no vendor to lose. | ||
| Security & compliance surface | A cart transform function receives cart data and returns operations; nothing leaves Shopify's runtime in either lane. | ||
| Platform-deprecation exposure | Coexistence rests on documented behavior Shopify can revise, and the selling-plan rejection looks structural rather than temporary. | ||
| Value | |||
| Fit to requirement | Apps model the bundles their schema anticipated; a function expresses a composition rule computed from your own cart and metafield data. | ||
| Time to market | A bundle goes live this week on any of the three apps, against 4–8 weeks for a function with fixtures (Deploi estimate, illustrative). | ||
| Performance & scale | Every installed app's cart transform runs on the same cart, so each additional function spends the same cart-computation budget. | ||
| Data ownership & AI-readiness | Bundle structure defined in a vendor dashboard is a vendor's schema; the same structure in metafields is queryable by anything you own. | ||
| Focus & opportunity cost | Keeping the app for the solved half is exactly what coexistence is for, and it keeps a sprint free for the half nobody sells. | ||
The App Landscape
| App | Status | Pricing | Best for |
|---|---|---|---|
| FBP | Fast Bundle & Upsell App | Live — 5.0★, 3,063 reviews; Built for Shopify. The largest review base in the category, with bundle, upsell and cross-sell features on every tier and pricing stepped by monthly bundle sales rather than by feature. Free to install on development stores. The listing does not state which cart transform operations the app runs, so confirm that with the vendor before scoping a second function. | Free to install for development stores; Standard (1K) $19/month or $180/year for up to $1,000 monthly bundle sales; Standard (3K) $49/month or $468/year; Standard (10K) $139/month or $1,380/year; 7-day free trial on paid plans (verified Sep 2026) | Stores that want the deepest review base and pricing that tracks bundle revenue |
| Simple Bundles & Kits | Live — Known for splitting bundle orders into component SKUs for fulfillment feeds | Free plan; $14–$1490/mo paid tiers at entry volumes; scales with volume (verified Sep 2026) | Plus stores that want advanced order rules without writing a function |
| Zoorix: Bundles & Cross Sell | Live — 4.9★, 391 reviews; Built for Shopify. The Forever Free plan includes every feature (cross-sell, bundles, volume discount, cart drawer, mix and match, recommendations) with Zoorix branding shown; paid tiers remove branding and are sized by the revenue the app generates, $100–200 a month on Basic up to $400–800 on Premium (verified Sep 2026). | Forever Free (all features, branding shown); Basic $7.99/month; Growth $14.99/month; Premium $29.99/month; 30-day free trial on paid plans (verified Sep 2026) | Bundles plus cross-sell and a cart drawer from a single low-cost app |
| Custom cart transform function (custom app) | Build lane — Your own function using linesMerge, lineExpand and lineUpdate to present components as one bundle line with a price, title and image you compute. Only development stores or Plus stores can use apps with lineUpdate operations, and custom apps containing Function APIs are Plus-only. One cart transform function per app per store; functions from several apps all run. | $12,000–$35,000 one-time plus upkeep (Deploi estimate, illustrative) | Plus merchants with a composition rule the app's schema has no field for |
The Build Path
- Confirm what the installed app's function actually does: Ask the vendor which cart transform operations its app runs, because none of the three listings states it. The install cap is one cart transform function per app, so your custom app gets its own slot no matter what the answer is. What the answer decides is whether the two functions ever touch the same cart lines.
- Scope your function to lines the app does not own: Namespace by product tag, collection or a metafield your function reads and the app never sets. Coexistence is safe when the two functions operate on disjoint lines, and it is only interesting when they do not. Write that boundary down as a rule your merchandising team can follow, not as a comment in the code.
- Handle the selling-plan case explicitly: Shopify rejects lineExpand, linesMerge and lineUpdate operations if a selling plan is present, on every plan including Plus. Detect the selling plan and return no operations rather than letting the platform reject them, so your logs show intent instead of noise. Subscription bundle pricing belongs to the subscription app.
- Consolidate when collision is unavoidable: When both functions must rewrite the same line, one of them has to be the authority. Shopify runs every app's function and publishes no ordering between them, so the only reliable answer is a single function that owns the line. That usually means replacing the app's bundle logic with yours, and paying the app's cost in scope.
- Effort band
- $12,000–$30,000 for one production cart transform function with fixtures and collision tests — Deploi estimate (illustrative); lands in the $25–75K contact-form band
- Typical timeline
- 4–8 weeks to a production function (Deploi estimate, illustrative)
- Maintenance, honestly
- ~15–20% of build cost per year (Deploi estimate): roughly $1,800–$6,000/yr (Deploi estimate, illustrative) for API version bumps, fixture upkeep and a re-test whenever the bundle app ships a change.
- What you own — and what you take on
- You own: the composition rule, its metafield inputs, the fixtures and the collision boundary between your function and the app's. You take on: a Plus dependency on two counts, and responsibility for behavior when both functions run on one cart.
3-Year Total Cost of Capability
| Buy (app path) | Build (custom path) | |
|---|---|---|
| Year 0 (setup) | $0–$500 | $12,000–$30,000 |
| Years 1–3 (recurring) | $0–$5,364 (bundle app subscription) | $5,400–$18,000 (maintenance) |
| 3-year total | ≈$0–$5,864 | ≈$17,400–$48,000 |
- † All figures illustrative samples for the reference scenario — not quotes, not verified pricing.
- † Left column keeps the bundle app at its highest listed tier, held flat; coexistence means paying this column as well as the right one, not instead of it.
- † Right column is one custom cart transform function with fixtures and collision tests; three-year horizon.
What the Sticker Price Hides
On the buy path
- — None of the three listings states which cart transform operations its app runs, so collision analysis starts with a vendor question rather than a doc page
- — Bundle app tiers step with bundle sales volume, so FBP moves from $19/month to $139/month as the program grows (verified Sep 2026)
- — Every installed app's cart transform runs on the same cart, so a bundle app nobody uses still executes until it is uninstalled
- — Free tiers carry conditions: Zoorix shows app branding on Forever Free, and Simple Bundles caps its free plan at 3 bundles and 50 monthly orders (verified Sep 2026)
On the build path
- — Shopify documents that functions from more than one app all run, and documents no order between them, so collision behavior is yours to design and test
- — The lineUpdate operation needs a development store or a Shopify Plus plan, and custom apps containing Function APIs are Plus-only, so the build assumes Plus twice
- — Cart transform operations are rejected outright when a selling plan is present, which puts subscription carts outside this mechanism on every plan
- — ~$1,800–$6,000/yr upkeep (Deploi estimate, illustrative)
What Merchants Say
Dev leads describe the coexistence question arriving late: a bundle app already in production, a new cart rule scoped and approved, and nobody certain whether the two functions would fight.
The recurring bundle-app complaint is representation rather than pricing: the cart shows components where the shopper expected one line, or one line where they expected components, and support tickets follow.
If You Change Your Mind Later
If you bought and outgrow it
Uninstalling a bundle app takes its cart transform function with it, along with the bundle definitions stored in the app. Your own function keeps running untouched, because the install cap is per app. Export the bundle catalog before the last billing cycle rather than after it.
If you built and want out
Removing your function restores whatever the remaining apps do, immediately and with nothing stranded, because a cart transform holds no state. The rule stays in your repository and can be redeployed. The Plus dependency is the real tie: a custom app containing a function stops installing without it.
When This Answer Changes
We're watching for:
- ▸ Shopify documenting an execution order between cart transform functions from different apps, which would turn today's design problem into a setting
- ▸ A bundle vendor publishing which cart transform operations its app uses, which would take the guesswork out of collision analysis
- ▸ Any change to the selling-plan rejection, which today blocks lineExpand, linesMerge and lineUpdate on subscription carts regardless of plan
Verdict change log:
No changes since first publication (September 2026).
Common Questions
Can two cart transform functions run on the same store?
Yes. Shopify states that a store can install a maximum of one cart transform function per app. Shopify also states that if a store has cart transform functions from more than one app, all of them run. The two rules are distinct: the cap is per app, and coexistence is across apps. A custom app gets its own function slot beside a bundle app's, so 2 functions run on the same cart.
Do I need Shopify Plus to run my own cart transform function?
Yes, in production. Shopify states that only development stores or stores on a Shopify Plus plan can use apps with lineUpdate operations, and that only Plus stores can use custom apps containing Shopify Function APIs. A development store prototypes the function without Plus. Bundle apps distributed publicly serve every plan, from free to $149/month (verified Sep 2026).
What happens when a subscription is in the cart?
Cart transform stops. Shopify rejects lineExpand, linesMerge and lineUpdate operations if a selling plan is present, which means subscription lines cannot be merged, expanded or repriced by any cart transform function. The restriction applies on every plan as of September 2026, Shopify Plus included, and to bundle apps exactly as to your own function. Bundle pricing for subscribers has to come from the subscription app or a discount.
Your Next Steps
If you're going with CUSTOMIZE(matches your selected profile)
- Ask the bundle vendor which cart transform operations its app runs, since no listing states it
- Write down which cart lines each function owns, keyed on a tag or metafield the other never sets
- Build fixture carts for the overlap cases, including a cart holding both a vendor bundle and your composed line
- Detect selling plans and return no operations, rather than letting Shopify reject them
- Re-test the boundary whenever the bundle app ships an update, because its behavior is not versioned for you
If you're going with BUILD
- Confirm the consolidation case: both functions must rewrite the same line and no namespacing separates them
- Model bundle structure in product metafields so the definitions survive uninstalling the app
- Port the app's existing bundles before you cancel, and reconcile inventory behavior on the merged line
- Keep the function inside the documented budgets, including a 3,000-byte input query and a 20 kB output
- Confirm Plus stays in the plan, because lineUpdate and custom function apps both require it
Official Docs & Sources
- Cart Transform Function API — 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.
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.
Core Checkout Steps vs. Thank You: What's Plus-Only?
Custom UI on the information, shipping and payment steps is Plus-only; Thank You and Order Status extensions are open on every plan except Starter.
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.
Adding a cart transform next to an app you already run?
We map which cart lines each function owns before anyone writes code, test the collision cases with fixture carts, and keep the bundle app doing the job it already does well.
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.