Tweakify
A Shopify app that adds unlimited custom product options with conditional logic and live pricing that's re-verified server-side by a real Shopify Function — so the price a shopper sees is the price they're charged.
- 80 option types
- 72 fully built
- Re-priced server-side
- shown price = charged price
- Parity-tested
- storefront and checkout stay identical
The problem
Shopify caps a product at three options and a hundred variants, which breaks the moment you sell anything personalized — an engraving, a monogram, made-to-order dimensions. The usual workaround is to fake variants, which is fragile and doesn't scale. Tweakify adds unlimited options without touching Shopify's variant system, and makes sure the price shown is the price charged.
What it does
A merchant builds 'option sets' in an embedded admin builder from a large catalogue of field types — text, uploads, dates, dimensions, choices, and more — and assigns them to products. On the storefront, fields can show, hide or require one another based on other answers or the product itself, and a running price updates live as a shopper fills them in.
When the shopper adds to cart, their choices are attached to the line, and a real Shopify checkout function independently re-calculates the add-on price from the merchant's saved configuration before checkout — so the total is never just trusted from the browser. Customer uploads go into the merchant's own Shopify Files, and the order page shows each customized line's options and attachments clearly.
Key features
Unlimited options, no fake variants
Add as many custom fields as a product needs without creating Shopify variants, so the 3-option/100-variant ceiling simply never applies to personalized products.
The price shown is the price charged
A real server-side checkout function re-derives the add-on price from the saved configuration, so a shopper can't tamper with the browser total and a merchant never under-charges by accident.
Fields that show and hide intelligently
Options can appear, hide or become required based on other answers or the product's own price, tags or type — so a long form only ever shows what's relevant.
A rich field catalogue
Text, uploads, dates, dimensions, choices, swatches and more mean almost any made-to-order product can be configured without custom code.
Uploads land in the merchant's own storage
Customer file uploads go straight into the merchant's Shopify Files, so a personalization photo is durable and tied to the order, not stranded on a third-party server.
Speaks your merchants' language
The builder and storefront are localized across eight languages, so option sets work for merchants and shoppers well beyond English.
Where it stands
Development complete and localized across eight languages — awaiting Shopify App Store review. Server-side charging is unit- and parity-tested and validated on a Shopify development store.
Under the hood — for the technically-minded
How it's built
The builder and storefront share one vanilla-JS core — a field registry, an event bus, and condition, pricing and validation engines — so what a merchant configures and what a shopper sees stay in lockstep. The storefront renders as a theme app block, keeping options fast and native to the product page.
The charge-authoritative path is a real compiled Shopify Function (a Cart Transform, running as WebAssembly at checkout) that decodes the shopper's choices against the product's mirrored option-set configuration and re-prices the line via Shopify's own cart-transform API. Because that runtime can't import the browser's code, the pricing logic is a deliberate, hand-synced port kept honest by byte-for-byte parity tests — client totals are treated as display-only throughout.
The hard problems
Beating Shopify's variant ceiling without faking variants
The team explicitly considered and rejected the obvious workaround — generating shadow variants on an app-owned product — reasoning through combinatorial explosion, add-to-cart latency, and the danger of deleting variants still referenced by abandoned carts. Choices become line-item properties instead, and nothing is ever a SKU, so the ceiling never applies.
A price the shopper can't tamper with
The headline isn't that the price updates live — it's that a real server-side Function re-derives it independently at checkout. The browser total is display-only; the charge is computed from the merchant's saved config in an isolated runtime, so what's shown and what's charged provably match.
One pricing rule, two runtimes, kept identical
The storefront engine and the checkout Function run in different environments and can't share code directly, so the pricing logic exists twice — and a parity test suite exists specifically to guarantee the two implementations produce byte-identical results, so they can never quietly drift apart.
Built with
- Remix
- Shopify Functions
- Prisma
- Postgres
- WASM
Building something in this space?
Work with us →