A Rebuy Alternative: Native Shopify Checkout Blocks

We replaced Rebuy for a subscription-heavy DTC brand on Shopify Plus with native checkout blocks we built ourselves. Same surfaces Rebuy sells: cross-sells in the checkout page and the cart drawer. The difference is the store now owns them, the $360 a month in Rebuy billing is gone, and the reporting we get out of it is deeper than anything the app's dashboard ever showed us, including the one number that actually matters for a subscription business.

The whole pattern is open source: shopify-checkout-cross-sell on GitHub (MIT) has the extension, the cart-drawer reference, and the reporting script, with one config file to adapt to your catalog.

Updated September 25, 2026: the numbers below started with three days of data. After five and a half weeks and 113 cross-sold orders, the take rate is 3.6% of web orders and holding, and the early subscription number came down to earth. Full results in the update section.

Why We Ripped It Out

This store has an architecture that breaks most apps' assumptions. There are no Shopify selling plans and no subscription app. "Subscription" is just a variant flag on the SKU, and the actual recurring billing runs in an external backend the brand has used for years. Shopify handles catalog, cart, and checkout. That's it.

Upsell apps are built around selling plans. This isn't us reading tea leaves: Rebuy's own dev team told us they couldn't support what we needed, because their subscription features only work with selling plans. That answer is what kicked off the build.

The reporting had the same blind spot. What we got was attributed revenue at the order level, in the app's own dashboard, with no way to see what happened to a customer after the add. For a business where the entire economics live in whether a customer ends up on the recurring program, that's reporting on the wrong thing.

The client is on Shopify Plus, which means Checkout Extensibility: you can render your own blocks inside the actual checkout page (info, shipping, payment steps) with Shopify's component library. That's the same surface the apps build on, which makes the checkout itself the most flexible Rebuy alternative there is: an agency can build the exact blocks the store needs, with the exact data model the store has.

What We Built

A checkout UI extension with a cross-sell block, plus the same offers ported into the theme's cart drawer. Both surfaces run the same brain:

• A curated offer table. Each core product maps to up to three cross-sell products, ordered by what actually sells. No algorithm pretending to know the catalog better than the merchant does.
• Family exclusion. If any product from a family is already in the cart, nothing from that family gets offered. Nobody sees an upsell for the thing they just added.
• Size preselection. If the cart says the customer wears a Large, the offer defaults to Large, mapped across products that size differently (one product's L is another's XL/XXL).
• One-tap add for single-variant products, a two-step picker for sized ones.

A generic rendering of the offer card. Curated product, size preselected from what's in the cart, one tap to add.

Offers add the one-time variant on purpose. A separate per-line card then offers to switch that line to the subscription variant with the real savings computed from live prices. That card deserved its own write-up, because in-checkout variant switching is the thing we could never get out of Rebuy, even paired with another app.

Claude Code built both surfaces inside the repos, the same workflow we use to build Shopify landing pages: the checkout extension in its own app repo, the cart version as a port of the same logic into the theme's jQuery drawer. The checkout block is merchant-placeable, so the client drags it wherever they want in the checkout editor without a redeploy.

The Attribution Layer Is the Whole Trick

Every add writes hidden line-item properties onto the order at the moment it happens:

_cross_sell: "checkout"       # which surface sold it: checkout or cart
_cross_sell_anchor: "..."     # which product in the cart earned the offer
_cross_sell_slot: "2"         # position 1-3 in the offer list
_cross_sell_size: "preselected"  # did our size guess hold, or did they change it
_sub_switch: "cart"           # the line was switched to subscription, and where

Underscore-prefixed properties are invisible to the customer but land on the order and stay queryable forever. That's the entire analytics stack. No pixel, no app database, no vendor dashboard. The order itself carries its own attribution.

The whole system. Two surfaces, one brain, and attribution that lives on the order itself.

One practical wrinkle worth stealing: we don't even need Shopify admin access to report on it. Klaviyo's Shopify integration mirrors the full order payload, properties included, so a script pulls Placed Order events through our Klaviyo CLI and computes everything from there. Useful when your agency seat doesn't have the Orders permission, and it's the same mirror we lean on for the metrics Klaviyo doesn't give you.

What the Report Shows

The weekly report answers questions the app dashboard never could. From the first three days of tracked data:

• Take rate: 9 of 296 web orders carried a cross-sell line, 3.04%. Web orders only in the denominator, because a quarter of this brand's volume is Amazon and never sees a checkout.
• Direct cross-sell line revenue: $335 in those three days.
• Slot performance: position 1 took 5 of the 9 adds. The curation order is doing its job.
• Size behavior: we can see whether customers kept the preselected size or changed it, which tells us whether the size mapping is right per product.
• Per-anchor performance: which product in the cart actually earns the adds, separate from which product got added.
• Surface split: cart adds and checkout adds report as separate rows, so we'll know where the offers actually convert instead of guessing.

The Number the App Could Never Show Us

Of the 9 cross-sold orders, 4 switched the added product to a subscription before paying. That's the compounding story: the cross-sell adds a one-time product, the switch card converts it to recurring, and the stamps record the whole chain on the order. (Over five and a half weeks that rate settled at 17%, not 44%. See the update.)

A $30 one-time add is a $30 win. The same add switched to a subscription feeds the external billing program, and the value is a multiple of the first order. Because this brand's subscriptions don't exist inside Shopify at all, no app dashboard was ever going to connect an upsell to recurring revenue. Two line properties connect it for free.

We report the caveats too: take rate is per-order rather than per-impression (some carts legitimately render no offers), and the AOV comparison between cross-sold and other orders has selection bias baked in, since bigger carts get more offers. Deeper reporting includes being honest about what the numbers can't say.

Update, September 25: Five and a Half Weeks In

Three days was enough to show the system worked. It wasn't enough to say how well. From August 18 to September 25, with both the cart drawer and checkout live and stamped, the cross-sell landed on 113 of 3,165 web orders, a 3.6% take rate, up from 3.04% in the checkout-only launch window. The last seven days ran 4.6%.

Two orders took an offer on both surfaces, which is why the surface rows add to 115, not 113. Revenue here is first-order only: the cross-sold line's price on the order that added it.

It holds week to week

The weekly rate stayed between 3.3% and 4.9% in five of six weeks. The exception was September 14 to 20, which dipped to 2.4% (13 orders, with two days at zero). At roughly 20 cross-sold orders a week, one slow week is noise until it repeats, and the following week came back at 4.9%.

The cart drawer added take rate instead of splitting it

The two surfaces pull almost exactly equal weight: 59 orders from the drawer, 56 from checkout. Checkout on its own dropped from 3.0% to 1.8% once the drawer went live. That reads as the same customers taking the offer one step earlier, not as checkout getting worse, and the combined rate is what went up. If you only have budget for one surface, this suggests the drawer earns its keep. If you have both, report them together.

Slot order works in checkout, not in the drawer

In checkout, position does what you'd expect: slot 1 took 37 of 68 adds. In the cart drawer, slot 3 outsold slot 1, 25 adds to 22. Same offers, same order, different result. Our read, not something the data proves: in a drawer shoppers scan the whole list, while in checkout they take the first reasonable thing. We wouldn't have known without the slot stamp, and it changes how we curate: the drawer's third slot is real estate, not a leftover.

Size preselection is right 96% of the time

Of the 105 adds where the product had a size choice, 101 kept the size we preselected from the cart and 4 changed it. The size mapping across products that size differently is doing its job.

What sells is cheap and obvious, what earns is premium

The workhorse is a $30 add-on accessory offered in slot 1 against the brand's bestselling core product: 53 of the 128 adds. The two premium items at about $90 a line are the opposite: 30 adds, 23% of the volume, but $2,521, or 42% of the revenue. That core product's carts produced 71 of the 128 adds on their own, which tells us where to spend curation effort next.

The headline AOV comparison turned out to be mostly a cart-mix effect. Cross-sold orders averaged $122.70 against $53.22 for other web orders, but about half of this brand's web orders are low-priced trial kits, and those take offers far less often. Split by cart type, the picture is cleaner:

• Full-size carts: 5.3% take rate. Orders that took an offer averaged $136.22 against $89.90 for those that didn't, with $50.64 of added items on average.
• Trial-kit carts: 1.7% take rate. Orders that took an offer went from about $15 to $77.45, with $58.96 of added items.

In both groups the gap between orders that took an offer and similar orders that didn't is close to the price of what was added. So the honest per-order number is about $53 of added items on each order that takes an offer, not the $69 raw AOV difference. The trial-kit split is also the next thing to work on: it's the biggest group of carts with the lowest take rate, which makes it the obvious place to test a different offer.

The subscription number, corrected

The launch window's "4 of 9 switched to subscription" was a small-sample high. Over five and a half weeks, 22 of 128 cross-sold lines ended as subscriptions, 17%. That's still a sixth of cross-sold lines turning into recurring revenue that no first-order revenue number counts, and it's the honest figure.

The bigger story is the switch card on its own. With the switch now stamped on both surfaces, 146 web orders (4.6%) contain a line the customer switched to subscription, more orders than the cross-sell touches. 23 of those switched lines were also cross-sold, which is the compounding path working as designed. The mechanics are in the switch-to-subscription write-up.

What this still can't see: take rate is per order rather than per offer view, the first day of the window undercounts cart adds while the drawer was being fixed, and none of the revenue above includes the recurring shipments from switched lines. All of those make the real numbers higher than what's reported, not lower. The cost side hasn't changed: $0 a month, against the $360 Rebuy was billing.

What It Took

The checkout extension, the cart drawer port, the attribution stamps, and the reporting script were built with Claude Code over a handful of working sessions, deployed behind a draft checkout profile first and QA'd on the live store. The offer table is a hand-curated map the client can change with a one-line edit. Ongoing cost went from $360 a month to zero, and the client owns the codebase.

If your store is on Plus and your upsell app is a black box with a monthly bill, the best Rebuy alternative may be no app at all. We open-sourced the whole pattern, MIT licensed: github.com/BeauchampAndrew/shopify-checkout-cross-sell has the extension (config-driven offers, the switch card, the attribution stamps), the cart-drawer reference implementation, and the reporting script. And if you want help building it, talk to us.