# Profiter — full content

> Profiter runs your spin-to-win popup and measures the profit it adds. A holdout control group and your real margins show what you earned after discounts and shipping.

Site: https://get-profiter.kraftpixel.com
Generated at build time from the same sources the pages render.

---

## What Profiter is

Profiter is a spin-to-win discount popup for Shopify. Shoppers spin a wheel for a
discount; the merchant captures a lead and hands out a code. The part that differs
from other wheel apps is measurement: a holdout control group never sees the wheel,
and the dashboard reports profit per exposed visitor against that control, computed
from the merchant's own margin and shipping inputs. That answers "did this popup
make money after the discounts it gave away", rather than "how many spins did it get".

Architecture facts that matter:

- Prize selection runs server-side with a CSPRNG using the merchant's configured
  odds and per-slice stock caps. The browser is told which slice to land on only
  after the outcome is decided, so the wheel cannot be forced client-side.
- Each win claims a single-use discount code, minted ahead of demand and applied
  through the cart via Shopify Functions, so no shopper has to copy-paste a code
  and no spin waits on Shopify's API.
- Holdout bucketing is a deterministic FNV-1a 32-bit hash of visitor ID and
  experiment ID, so a visitor stays in the same arm across sessions without
  server-side state.
- Sample-ratio mismatch is checked with a chi-square goodness-of-fit test at
  alpha = 0.001 — deliberately stricter than the usual 0.05, because a false
  "your test is broken" alarm costs a merchant more than a missed one.
- Significance uses a two-proportion z-test with a 95% Wald confidence interval.

## Pricing

### Free — $0/month

Launch an on-brand wheel, capture leads, and prove what it earns.

Allowance: 1,000 spins / month

- Unlimited saved campaigns; 3 active wheels
- Product, collection and page targeting
- Email and phone capture with consent controls
- Six prize types with custom odds and redemption caps
- Auto-applied single-use discount codes
- All themes and design controls
- Holdout testing to measure true lift
- See profit after discounts and shipping
- Smart campaign recommendations

### Growth+ — $29/month

Reach more shoppers and send every lead straight to the tools you work in.

Allowance: 50,000 spins / month

- Everything in Free
- 10 active wheels
- Klaviyo, Mailchimp, and Omnisend lead sync
- Consent and double opt-in status synced with every contact
- Real-time Google Sheets lead and outcome sync
- Weekly and monthly reporting tabs
- Coupon reminder bar that keeps won codes on screen
- Hide the won code on the wheel and deliver it your way

### Pro+ — $47/month

Unlimited spins, with every win messaged and automated.

Allowance: Unlimited spins

- Everything in Growth+
- Unlimited active wheels
- WhatsApp prize follow-ups
- Zapier, Make.com, and custom webhook automations
- Priority support

Included on every plan, at no cost:

- Unlimited saved campaigns
- Product, collection and page targeting
- Secure server-side prize selection
- Six reward types
- Custom prize odds
- Prize redemption caps
- Spins-per-visitor controls
- Auto-applied single-use discount codes
- Email and phone lead capture
- Consent and double opt-in controls
- All themes and full styling
- Keyboard, ARIA and AA-contrast accessibility

Measurement is free on every tier. The paid plans sell reach and integrations,
never the ability to measure. Merchants are notified at 80% and 95% of their
monthly spin allowance; nothing is paused at the cap.

## Prize types

- **Percentage off** — Order-wide or specific products
- **Fixed amount off** — With optional minimum spend
- **Free shipping** — Optional max shipping cap
- **Free gift** — 100% off a chosen product
- **Buy X get Y** — BOGO at any discount %
- **No win** — Honest odds keep margins safe

## Integrations

- **Klaviyo** — Growth+
- **Mailchimp** — Growth+
- **Omnisend** — Growth+
- **WhatsApp** — Pro+
- **Google Sheets** — Growth+
- **Zapier** — Pro+
- **Make.com** — Pro+
- **Webhooks** — Pro+

## Storefront weight (measured, not estimated)

- **Profiter** (this app): 2 file(s), 12.5 KB gzipped. Source: measured from the built theme-extension assets in this repo
- **Wheelify**: 11 file(s), 92.0 KB gzipped — 650 App Store reviews. Source: measured on freedsbakery.com, a live store running it; 11 files under cdn.shopify.com/extensions/…/spin-wheel-1-173/assets/

Measured 29 August 2026 in Chrome, counting every file each app loads on a storefront page before a shopper touches anything: 2 for Profiter, 11 for Wheelify. Both figures are gzipped. Wheelify is the most-reviewed spin-the-wheel app on the Shopify App Store (650 reviews, 4.8 stars) and was measured on a live store running it. Compression and settings move these numbers a little, so read them as a typical install rather than a fixed constant.

## Frequently asked questions

### How is this different from every other spin-wheel app?

Other apps report spins and signups. Profiter keeps a holdout group that never sees the wheel and compares profit per visitor, so you learn whether the popup made money after discounts and shipping.

### Can shoppers cheat the wheel or force a jackpot?

No. Our server picks the winning slice with a secure random generator, using the odds and stock limits you set. The browser only learns which slice to land on after the decision is made.

### Will it keep up during a flash sale?

Yes. Profiter mints discount codes ahead of demand, so each spin claims one that's already waiting instead of queueing on Shopify's API. The wheel starts turning the instant a shopper taps, and the prize lands mid-spin.

### Do customers have to copy a discount code?

No. Every win creates a single-use code and applies it through the cart, so the discount is already waiting at checkout.

### What counts toward my plan's spins?

Each time a shopper spins the wheel counts as one. Free covers 1,000 spins a month and Growth+ covers 50,000; Pro+ is unlimited. We notify you at 80% and 95% of your allowance so nothing takes you by surprise.

### Which email and messaging tools does it sync with?

Klaviyo, Mailchimp and Omnisend sync plus real-time Google Sheets on Growth+; WhatsApp prize follow-ups and Zapier, Make.com or your own webhook on Pro+ — every lead is sent the moment it is captured, consent and double opt-in status included. CSV export is available on every plan.

### Can I run different wheels on different products or pages?

Yes, on every plan. In each campaign’s Audience step, choose products, collections or Online Store pages, or use the whole store as a fallback. A collection rule covers its collection page and product pages for items in that collection.

### How many campaigns can stay active at once?

Free includes 3 active wheels, Growth+ includes 10, and Pro+ includes unlimited active wheels. Every plan lets you save unlimited campaigns. Active campaigns scheduled to start later also use a slot. Pause a campaign to free a slot or upgrade for more.

### What happens when two campaigns match the same page?

Only one wheel appears. Product and page rules take priority over collection rules, followed by the whole-store fallback. Among campaigns with the same targeting type, the higher priority wins. Equal priorities use a stable tie-break, so results stay consistent.

### Can I collect the email without handing over the code on the wheel?

Yes, on Growth+. Switch the code off on the wheel and winners see their prize plus a message you write. The code is still created for every win and waits next to that shopper's lead, so you can send it in your welcome email, on WhatsApp, or give it to them in person.

### Is it accessible and privacy-compliant?

Yes. Keyboard focus, ARIA labels and AA contrast are built in. The spin itself always plays: it is brief, it only ever follows the shopper's own tap, and a skipped spin reads as a broken wheel. Consent is never pre-ticked, shopper contact details are encrypted at rest, and Shopify's GDPR webhooks perform real deletion.

## What we do not claim

No customer counts, revenue figures, testimonials, star ratings, awards,
security certifications, compliance certifications, or conversion-lift
percentages appear anywhere on this site, because none of them exist yet.
Profiter implements specific accessibility practices (keyboard focus
trapping, ARIA dialog semantics, live-region result announcements, large
touch targets, AA contrast checks) but holds no WCAG certification and
claims no conformance level. The spin animation deliberately plays even
under prefers-reduced-motion: it is brief, runs once, and only ever follows
the shopper's own tap.

---

## Blog

### Accessible Popups: Designing a Spin-to-Win Wheel Everyone Can Use

- URL: https://get-profiter.kraftpixel.com/blog/accessible-spin-to-win-popup
- Category: Accessibility
- Author: Team Profiter
- Published: 2026-07-28

A keyboard-only shopper lands on your store, and a wheel pops up over the page. If the dialog doesn't trap focus properly, the tab key takes them somewhere behind the modal — a link, a menu item, anywhere but the wheel — and they can't reach the spin button or the close icon. They're not blocked by disinterest. They're blocked by code.

That shopper has two options: give up and leave, or fight the tab key until something works. Either way, the popup you installed to add a sale just cost you one instead.

A popup only helps your store if the person seeing it can act on it. An inaccessible control is a broken control, and a broken control costs you the sale whatever the compliance picture looks like. The four principles behind accessible design make a useful frame for walking through what that takes: perceivable, operable, understandable, and robust.

## Perceivable: Can everyone see and hear it?

Information can't be invisible to a shopper's senses. If the experience relies only on sight or only on sound, it will fail for someone.

### Screen readers hear what sighted shoppers see

The wheel spins, slows, and lands on a slice — all visual. A shopper using a screen reader can't watch that happen, so Profiter marks the popup up with proper ARIA dialog semantics and announces the result through a live region the moment the spin ends.

Practically, that means the screen reader reads out the prize — "10% off," "Free shipping," whatever the slice says — without the shopper needing to hunt for it on screen. The result reaches them the same moment it reaches everyone else, through the channel they're actually using.

### Colors have enough contrast to be read

Low-contrast text is hard to read in direct sunlight, on a low-quality screen, or for a person with low vision. Profiter's color combinations are checked for a minimum AA contrast ratio before they ship as a theme, so text stays readable against its background regardless of which of the six themes or custom color set a merchant picks.

## Operable: Can everyone use it?

An interface a shopper can perceive but not operate is a dead end. Every interactive element must work with a mouse, a keyboard, a screen reader, and a finger.

### Keyboard focus stays where the dialog is

Profiter's wheel traps keyboard focus inside the dialog while it's open, with visible focus rings so a keyboard user can always see where they are. Tab moves between the spin button, the form fields, and the close control — never out to the page underneath, and never into a dead end with no way back out.

That second part matters as much as the first. A focus trap that locks someone in with no visible way to leave is worse than no trap at all. The close control stays reachable and keyboard-operable at every step, so dismissing the wheel takes the same one keystroke it would for a mouse user clicking the X.

### Big targets are easy to hit

Small buttons are a mobile problem before they're an accessibility problem — a thumb misses a 30px tap target far more often than a 48px one. Profiter's interactive elements meet a minimum touch target size of at least 48x48 pixels, giving every user a forgiving target for their click or tap.

### Motion is brief and user-initiated

Spinning wheels are built to feel kinetic — that's the point of the format. Profiter keeps that motion inside deliberate bounds instead of scattering it everywhere: the wheel only spins after the shopper explicitly taps the spin button, the animation runs once for about four seconds and stops, and nothing loops or auto-plays in the background while the popup is open.

One trade-off, made openly: the spin plays even when the `prefers-reduced-motion` setting is on. Many phones ship with Reduce Motion enabled for battery or preference reasons, and a wheel that doesn't visibly spin reads as broken — shoppers assume the popup failed and leave. Because the animation is short, singular, and only ever a direct response to the shopper's own tap, we choose the version that everyone can actually use. The prize is decided server-side before the wheel starts moving, so the motion is presentation only — the odds never depend on it.

## Understandable: Is the experience clear?

An accessible interface is a predictable one. The process for using the wheel is simple by design: spin, see the prize, and get a code. There are no complex steps or confusing terms. The goal is to add a moment of fun, not a puzzle to solve.

## Robust: Does it work everywhere?

A popup has to load before it can be used. On a slow mobile connection or throttled public Wi-Fi, a heavy script is just as much of a barrier as a missing ARIA tag. We build Profiter to be lightweight by design, gating every new feature against a strict performance budget.

The entire storefront experience loads in two files totaling just over 13 KB.

| Asset       | Raw        | gzip       | brotli     |
|-------------|-----------:|-----------:|-----------:|
| `wheel.js`  | 21,293 B   | 8,681 B    | 7,759 B    |
| `wheel.css` | 23,847 B   | 6,731 B    | 5,742 B    |
| **Total**   | **45,140 B** | **15,412 B** | **13,501 B** |

<small>_Data measured 28 July 2026 from the built extension assets._</small>

This small footprint ensures the popup doesn't block the rest of your page from loading and remains usable even on slow networks. For context, the most-reviewed competing wheel app on Shopify loads 11 files totaling 94,236 B (gzipped) before a shopper does anything.

## Can popups be ADA compliant?

The Americans with Disabilities Act (ADA) doesn't provide a technical checklist for websites. Instead, it's a civil rights law that requires businesses to provide equal access to their services. Whether a specific popup is "compliant" depends on whether it creates a barrier for a person with a disability in a specific context.

Rather than claiming a legal status like "ADA compliant" or a specific WCAG conformance level, we focus on the verifiable implementation details that support the goal of equal access. The practices described here are not a badge on a landing page; they are implementation details you can go check in the theme extension code.

Accessible isn't an add-on mode you switch on for some shoppers and off for others. It's the same wheel, the same focus trap, the same announcement — running by default for everyone who sees it.

---

### Gamification in Ecommerce: Why a Spin Wheel Converts Better Than a Discount Banner

- URL: https://get-profiter.kraftpixel.com/blog/gamification-ecommerce-spin-wheel
- Category: Strategy
- Author: Team Profiter
- Published: 2026-07-28

A banner that says "10% off today" asks a shopper to take your word for it. A wheel that lands on "10% OFF" after they tapped spin gives them a moment where the discount looks like it was won, not handed over. Same 10%, different feeling — and that difference is most of why gamified popups outperform static ones.

## Why a "win" works harder than an offer

Two things are doing the work here, and neither of them is exotic.

The first is perceived agency. A banner is passive — it appears, and the shopper either notices it or doesn't. A wheel asks for a tap, and that small action changes how the result lands. A discount you did something to receive registers differently than a discount that was simply displayed at you, even when the underlying mechanism decided the outcome either way.

The second is variable reward. A banner always says the same thing. A wheel might land on 10% off, free shipping, or a bigger prize, and the shopper doesn't know which until it stops. Not knowing exactly what's coming holds attention longer than knowing you'll get the same thing every time — it's the same basic pattern behind why a slot machine or a raffle keeps people watching in a way a fixed price tag never does. This is general, well-worn reasoning from marketing and behavioral psychology, not a Profiter-specific claim, and there's no invented percentage attached to it here — it's a reason gamified offers tend to engage, not a promised result for any given store.

## But doesn't gamification slow down the store?

An interactive element like a wheel can be heavy, and page speed is a valid concern. Some gamified popups load a dozen files and add significant weight to a page before the shopper even sees them.

A performant wheel is a deliberate engineering choice. Profiter's entire wheel popup ships as two files totalling **15,412 bytes gzipped**, measured from the built theme extension on 28 July 2026. The most-reviewed wheel app on the Shopify App Store loads **94,236 bytes gzipped** across 11 files, measured in Chrome on a live store running it. Both numbers are gzipped, so they compare like for like — our brotli build is smaller still at 13,501 bytes, but quoting that against someone else's gzip figure would be comparing two different compression algorithms.

## Where gamification goes wrong

Here's the part that gets skipped in most "add a spin wheel" advice: engagement isn't the same as profit, and a wheel with generous odds doesn't automatically produce either.

If most slices pay out a real discount and the no-win slice barely shows up, you've built an expensive discount banner with a spin animation bolted onto it. This is common enough that our system automatically flags wheels where the "no-win" slice has less than a **20% chance** of appearing. Below that threshold, the game is effectively gone — it's just a flashy discount dispenser eating your margin. Similarly, we flag jackpot prizes that have a **1.5% or greater** chance of winning if they aren't also capped with a redemption limit. A lucky streak on an expensive prize shouldn't drain your budget for the month.

The failure mode is quiet, too. Spins go up, signups go up, and the dashboard looks busy — none of that tells you whether the store made more money after the discounts were paid out. A gamified popup can look like a clear success on every number that isn't profit.

## Getting the engagement without losing the margin

The fix isn't to make the wheel less fun. It's to control what it costs and check what it earns.

Profiter's prizes carry real odds you set per slice, so "everyone basically wins something good" is a choice you make deliberately rather than a default you inherit. This control is absolute because the prize is determined on our server using a cryptographically secure random number generator *before* the wheel animates. The browser is told which slice to land on; it animates a result that's already been decided, so the outcome can't be manipulated by a savvy shopper.

Per-slice inventory caps stop a prize from paying out more times than you're willing to fund, and a jackpot flag lets you mark rare, high-value prizes separately from routine ones. None of that requires guessing — the odds and caps are set in the same builder where you design the wheel.

The other half is measurement. Odds and caps tell you what you're willing to risk; they don't tell you whether it paid off. That's what a holdout group is for — a slice of traffic that never sees the wheel, so you can compare profit per visitor against shoppers who did. To ensure a visitor stays in the same group across sessions, we use a deterministic **FNV-1a 32-bit hash** of their visitor and experiment ID. Before we even show a result, we check for sample-ratio mismatch with a **chi-square goodness-of-fit test** to confirm the groups are truly comparable. If you want the mechanics of how that comparison works and how to read the result without fooling yourself, [the holdout test post](/blog/holdout-test-popup-profit/) covers it in full.

Put together, the sequence is: set odds and caps that protect margin, let the wheel do the psychological work a banner can't, and use the holdout to confirm the engagement actually turned into profit rather than just a livelier way to give away the same discount.

---

### 6 Discount Types You Can Offer Beyond a Flat Percentage Off

- URL: https://get-profiter.kraftpixel.com/blog/discount-types-beyond-percentage-off
- Category: Prizes
- Author: Abhishek Gharat
- Published: 2026-07-28

Most spin-to-win wheels ship with six slices of the same idea: 10% off, 15% off, 20% off, maybe a 50% jackpot. That's one lever pulled six times. Percentage-off discounts scale with the size of the cart, costing you the most on exactly the orders where you'd most like to keep your margin. Profiter builds six different prize types for a reason — percentage off, fixed amount off, free shipping, free gift, buy X get Y, and a genuine no-win slice. The cheapest way to make a shopper feel like they won depends on your margins, your average order value (AOV), and what's sitting in your warehouse. In fact, AOV is such a key factor that our own recommendation engine uses a hard threshold of $100 to decide between percentage and fixed-amount prizes.

## Percentage off: still right for order-wide incentives

Percentage off is the classic order-wide incentive. It's the clearest "spend more, save more" signal a wheel can send — 20% off feels the same whether the cart is $30 or $300. This makes it a good fit for stores with an average order value under $100, where a fixed amount might feel too small. But on a high-AOV store, a generous percentage jackpot can take a real bite out of your biggest orders. This is the core of the "Rule of 100," a heuristic Profiter's own recommendation engine uses: if your AOV is consistently over $100, a percentage-off prize is often a riskier choice than a fixed amount.

## Fixed amount off: the lever for raising average order value

A fixed amount off — $5, $10, whatever you set — with an optional minimum spend costs you the same dollar figure regardless of cart size. This protects your margin on large orders, making it the safer choice for high-AOV stores. If your AOV is over $100, a $20 discount is a much smaller percentage of the total than it is on a $40 order. You can use this to your advantage: set the minimum spend a little above your current average cart, and a $10-off slice stops being a flat cost and starts being a reason to add one more item before checkout.

## Free shipping: margin protection for low-AOV stores

If your average order is modest and shipping is a real line item, a percentage-off slice stacks on top of a cost you're already absorbing. Free shipping, with an optional max shipping cap, costs you a known number instead — the shipping bill itself, capped if you want a ceiling on it — rather than a discount that grows with the price of what's in the cart. On a low-margin, low-AOV store, it's often the cheaper prize to hand out, and shoppers tend to want it just as much as a discount.

## Free gift: clear inventory without discounting the cart

A free gift is 100% off one chosen product, not the order. That lets you move something specific — a color that isn't selling, last season's line — without touching the price on everything else the shopper is buying. It reads as a real prize to them. To you, it's the cost of one unit, not a percentage off the whole transaction.

## Buy X get Y: built for categories people reorder

BOGO, at whatever discount percent you set, earns its keep in categories where a second unit is genuinely useful — skincare, supplements, snacks, anything a customer goes through and buys again. It adds a unit to the cart instead of shaving the price on the units already there, which is a different piece of math from a straight percentage off, and usually a better one when the product itself is consumable.

## No win: the slice that keeps the other five affordable

A wheel with five generous prizes and no real no-win slice isn't generous, it's just a discount code with a spin animation. The payout rate shows up in your margin whether shoppers notice the wheel or not. A genuine no-win slice, set at honest odds, makes room for a real jackpot. Profiter's internal monitoring flags wheels where the no-win slice accounts for less than 20% of outcomes, as this often indicates the blended discount rate is too high to be profitable. A healthy no-win chance is what keeps the other five prize types affordable.

## What is a discount combination on Shopify?

Shopify has specific rules for how discounts can be combined at checkout. For example, a customer typically can't use two different percentage-off codes on the same order.

A spin-to-win wheel from Profiter simplifies this. The wheel itself presents a *combination of options*, but the shopper only wins *one* prize per spin. The prize is delivered as a standard, single-use Shopify discount code. This means:

1.  **The prize follows Shopify's rules.** If a shopper wins "15% off," that code will behave like any other 15% off code at your checkout, including its compatibility with other active discounts (like free shipping).
2.  **The outcome is guaranteed.** Profiter determines the prize on the server before the wheel even starts spinning and mints the code ahead of demand. This prevents shoppers from trying to game the spin and ensures the code is ready instantly.

The "combination" is in the variety of prizes you offer on the wheel, not in stacking multiple codes on a single order.

## Setting the mix so it pays for itself

Every slice in Profiter carries its own odds and its own stock or redemption cap. You're not picking one average discount rate; you're designing a prize distribution. A jackpot slice that's rare and capped costs far less over a month than an even split between two mid-size discounts.

But how do you know if the mix is actually profitable? Profiter measures this for you against a holdout control group that never sees the wheel. Visitors are deterministically bucketed using an FNV-1a hash of their visitor and experiment IDs, ensuring they stay in the same group across sessions without server-side state. We then compare the two groups using a two-proportion z-test to see if the wheel is genuinely increasing profit per visitor after accounting for the cost of discounts and shipping.

The same inputs drive a set of automated recommendations that watch for the setup mistakes that cost the most margin. Each rule fires on a specific threshold rather than a hunch.

| Rule | Trigger |
|---|---|
| **Rule of 100 (Percentage)** | AOV ≤ $100 and the wheel mainly gives fixed amounts. |
| **Rule of 100 (Fixed Amount)** | AOV > $100 and the wheel mainly gives percentages. |
| **Jackpot Margin Risk** | Jackpot probability ≥ 1.5% and no redemption limit is set. |
| **No-Win Share Too Low** | No-win slice probability is < 20%. |

Worth saying plainly where those numbers come from: they're defaults we picked and hard-coded, not thresholds derived from a pool of merchant data. The part that *is* independently checked is the maths they run on — 46 unit tests cover the measurement and recommendation modules, and the distribution functions behind the significance testing are verified against published reference values rather than assumed correct. Values current as of 28 July 2026.

Set the odds and the caps first, then check what the blended payout works out to before the wheel goes live. If you'd rather start with a proven formula, the [Rule of 100](/blog/rule-of-100-wheel-odds/) is the fastest way to match your prize types to your AOV.

---

### Exit-Intent Popups: What They Are and When to Use Them

- URL: https://get-profiter.kraftpixel.com/blog/exit-intent-popups-guide
- Category: Targeting
- Author: Abhishek Gharat
- Published: 2026-07-28

A shopper adds two shirts to their cart, scrolls back up, and moves the mouse toward the top of the browser window to close the tab. Nothing has been clicked yet. That movement — the direction the cursor is travelling, not any action taken — is the signal an exit-intent popup is built to catch.

## What exit-intent detection actually is

Exit intent works by watching the mouse. A script tracks cursor position and velocity, and when the pointer moves fast toward the top edge of the viewport — where the browser's tab bar, back button, and close button live — it treats that as a visitor about to leave and fires the popup before the tab actually closes.

But how much code does that script add to your page? For a feature that might not even fire for most visitors, the payload matters. For Profiter, the entire package that runs on the storefront — trigger logic, wheel physics, and all styles — is two files totalling 15,412 bytes gzipped, or 13,501 bytes where the browser accepts brotli.

| Asset | Raw | gzip | brotli |
|---|---:|---:|---:|
| `wheel.js` | 21,293 B | 8,681 B | 7,759 B |
| `wheel.css` | 23,847 B | 6,731 B | 5,742 B |
| **Total** | **45,140 B** | **15,412 B** | **13,501 B** |

<small>Payload measured 28 July 2026 from the built theme app extension assets. The browser uses the smallest format it supports, typically brotli.</small>

It's a proxy, not a certainty. Someone reaching for a different browser tab, or just resting their hand near the top of the screen, can trigger it too. But as proxies go, it's a good one: heading toward the chrome of the browser is something people mostly do right before they leave, and rarely do in the middle of reading a product page.

## Why it's a common trigger for discount popups

The appeal is timing. A popup that fires the second a page loads interrupts someone who hasn't decided anything yet. A popup that fires on exit intent only reaches shoppers who were already on their way out — browsing without buying, comparing prices in another tab, or just not convinced yet. Offering one more reason to stay costs nothing with a visitor who was leaving anyway, which is exactly why exit intent shows up so often as a trigger option on spin-to-win and discount popups: it targets the moment of departure instead of guessing at intent from time on page or scroll position alone.

## The limitation: it's for mouse users only

Exit intent depends on a mouse. This excludes two huge groups of shoppers: anyone on a touchscreen, and anyone navigating by keyboard.

There's no equivalent signal on a touchscreen. A shopper closing a mobile tab swipes up from the bottom, taps the back button, or switches apps, all in a single gesture with no warning motion for a script to detect. Some tools try to fake it by watching for a fast scroll toward the top of the page, but that catches people re-reading a product description just as often as people leaving, which makes it noisy enough to be more annoying than useful.

Likewise, a keyboard-only user gives no mouse-based signal before hitting `Cmd+W` to close a window. A truly accessible popup needs to be navigable and dismissible without a mouse, using ARIA dialog semantics and clear focus rings so the user never gets trapped.

This matters because mobile is where most Shopify storefront traffic actually is. A targeting setup that relies on exit intent alone reaches your desktop mouse users and goes silent for everyone else. If mobile and accessibility matter — and for most stores, they do — exit intent can't be the only trigger in the setup. It needs a partner built for other contexts: scroll depth (fire once someone passes a percentage of the page) or a time delay (fire after a fixed number of seconds), either of which works regardless of the input device.

## Pairing exit intent with a frequency cap

Exit intent solves *when* to show a popup to someone about to leave. It doesn't solve *how often* to show it to someone who comes back. Without a limit, a visitor who browses your store three times in a week gets the same popup three times, which turns a well-timed offer into the thing they start closing on reflex.

A frequency cap fixes that by remembering the visitor and skipping the popup until a set number of days has passed since they last saw it. Combined, the two triggers do different jobs: exit intent decides the moment within a single visit, and the frequency cap decides whether this visit even qualifies for a popup at all. A returning shopper still gets caught if they're heading for the exit, but not on every single trip.

## Building the whole picture

None of these triggers works alone for a real store. A practical setup usually layers exit intent for desktop, a scroll or time trigger for mobile, and a frequency cap over both so repeat visitors aren't hit every session. Device targeting ties it together — showing the exit-intent version only to desktop traffic and the scroll or time version only to mobile, rather than running every trigger for every visitor and hoping the popup logic sorts it out.

Profiter's audience step supports all six of these — exit intent, scroll depth, time delay, device targeting, frequency cap, and a max-spins-per-visitor limit — as configurable options rather than a fixed default, so the combination above is a setting, not custom code. But the reasoning holds regardless of which app runs it: exit intent alone leaves more than half your traffic untouched, and any trigger without a frequency cap eventually annoys the people it keeps hitting.

---

### Rule of 100: A Simple Way to Set Fair Wheel Odds Without Losing Money

- URL: https://get-profiter.kraftpixel.com/blog/rule-of-100-wheel-odds
- Category: Strategy
- Author: Abhishek Gharat
- Published: 2026-07-28

Retailers have used a rough gut check on discounts for decades: multiply the discount percentage by the price, and see where you land. Under 100, the discount reads as a reasonable slice of the ticket price. Over 100, it's disproportionate — deep enough that most retailers price it as a flat dollar amount instead of a percentage, because the percentage alone would look, and cost, more than the item can carry. It's the reason a $5 item might advertise "20% off" while a $500 item advertises "$40 off" for a similar-sized discount — the same percentage on the pricier item fails the check by a wide margin.

That's the Rule of 100, and it's older than spin-to-win popups. But it turns out to be exactly the right question to ask about a prize wheel.

## Applying it to a wheel's prize mix

A wheel's slices aren't abstract. Each one is a discount percentage attached to whatever the average order on your store looks like. Run the same multiplication: discount percentage times your average order value. A 10% slice against a $60 average order comes out to 600 — comfortably over 100, and worth a second look if it's winnable often.

Generous prizes are the point. Jackpots are part of what makes a wheel worth spinning. The check is about knowing, before the wheel goes live, whether a slice that looks great in the campaign builder is one your margin can actually absorb. Profiter's recommendations engine flags a **jackpot margin risk** whenever a prize's win probability is 1.5% or higher with no redemption limit set. A big prize has to be rare as well as exciting, or a traffic spike turns it into an unplanned discount on every order.

## No-win share is the other half of the equation

A prize mix can pass the Rule of 100 on every individual slice and still lose money for a different reason: not enough spins land on nothing. If the "no win" slice is thin, nearly every visitor who plays walks away with a discount, whether or not the wheel changed their mind about buying.

A prize mix with honest odds needs a no-win share doing real work. But how much is enough? Profiter's engine uses a concrete threshold, flagging campaigns where the no-win share has dropped below 20% of total spins. Below that line, the wheel risks becoming a standing discount for every visitor rather than an incentive for undecided ones.

## Are spin-the-wheel discounts rigged?

Search for spin wheel odds and you'll find questions about cheating, hacks, and whether the wheels are rigged. It's a fair question, as the animation on many wheels feels more like a video than a game of chance. The answer depends on where the prize is decided.

In a client-side wheel, the browser's code determines the outcome, making it possible for a savvy user to inspect the code and manipulate the result. A server-side wheel works differently. With Profiter, the prize truth is server-side. The browser learns which slice to land on only *after* a cryptographically secure pseudo-random number generator (CSPRNG) on our server has already picked a winner based on the merchant's odds. The wheel simply animates to that pre-determined result. This prevents any manipulation from the shopper's browser.

## Profiter checks your odds automatically

This is exactly the pattern Profiter's recommendations engine watches for on every campaign. You don't have to run the multiplication by hand or remember to check back — the campaign builder surfaces it while you're still setting odds, before the wheel goes live. It runs on a specific, rules-based system developed from real campaign data.

| Rule | Trigger | Why it matters |
|---|---|---|
| **Jackpot Margin Risk** | Jackpot win chance ≥ 1.5% (with no redemption limit) | A generous jackpot can become an accidental standing discount if it's won too often. |
| **No-Win Share Too Low** | "No win" slice < 20% of total odds | If nearly every spin wins, the wheel isn't changing behavior—it's just giving away margin. |
| **Rule of 100 Mismatch** | AOV > $100 with % prizes, or AOV ≤ $100 with fixed prizes | The prize format feels wrong for the price point, hurting perceived value. |

These checks fire after a campaign has at least 1,000 exposed visitors, ensuring the recommendations are based on a reliable sample. That's the difference between guessing at "generous enough to be fun" and knowing where the line to "too generous to be profitable" actually sits — and it's the same question a holdout group answers from the other direction: not what the odds look like on paper, but [what the wheel actually did to your profit](/blog/holdout-test-popup-profit/) once it was live.

---

### The Holdout Test: How to Know If Your Popup Actually Makes Money

- URL: https://get-profiter.kraftpixel.com/blog/holdout-test-popup-profit
- Category: Measurement
- Author: Abhishek Gharat
- Published: 2026-07-28

A spin-to-win popup can hit every vanity number you'd want — thousands of spins, a healthy signup rate, a wall of "10% OFF" codes handed out — and still lose you money. Discounts cost margin. Free shipping costs your shipping budget. If the shoppers who would have bought anyway are the ones claiming the code, you paid for a sale you already had.

The only way to know the difference is to compare against shoppers who never saw the popup at all.

## What a holdout group actually is

A holdout is a slice of your traffic — say, 10% — that the app deliberately excludes from the wheel. They browse and buy exactly as they would if you'd never installed a popup. Everyone else sees the wheel as normal.

Because the split happens per visitor and stays consistent, you get two comparable groups over the same traffic, the same marketing spend, and the same time period. The only difference between them is whether they saw the wheel. Profiter makes this split deterministic by hashing the visitor's ID with the experiment ID using the FNV-1a algorithm. This means the same visitor always lands in the same group across sessions, with no server-side state needed.

Whatever profit gap shows up between the two groups is the wheel's effect — not seasonality, not a traffic spike, not a sale you were already running. Compare that to before/after: "spins went up in March" tells you nothing, because March might have had a promotion, more ad spend, or just more visitors. A holdout removes that ambiguity by running both conditions at the same time.

## Spins and signups aren't the metric

A spin is an impression. A signup is a lead. Neither one is money, and both are easy to inflate without helping your business — generous odds and a low-friction form will pump both numbers while your margin quietly erodes underneath.

The number that matters is **profit per visitor**, computed after the real costs: the discount given, any free shipping absorbed, and your margin on what was actually sold. Profit per visitor in the wheel group, compared to profit per visitor in the holdout group, is the only comparison that tells you whether the popup is worth running.

If margin per visitor is *higher* in the wheel group than the holdout, the popup is adding profit. If it's lower — even while spins and signups look great — the discounts are outweighing whatever extra purchases the wheel is generating.

## Reading the result without fooling yourself

A few things worth knowing before you trust a number. Profiter's measurement stack is built to prevent common statistical traps. Here's how it works:

| Test | Method | Profiter's Implementation |
|---|---|---|
| **Group Integrity** | Sample Ratio Mismatch (SRM) | A **Chi-square goodness-of-fit test** runs automatically. It uses a strict significance level (alpha = 0.001) to check if the traffic split matches the percentage you set. |
| **Statistical Significance** | Two-proportion z-test | A **two-proportion z-test** calculates the probability that the observed difference in profit per visitor is real, not random chance. Results are shown with a 95% Wald confidence interval. |
| **Result Reliability** | Minimum sample size | A result is only called "reliable" after the test has seen at least **1,000 exposed visitors**. A gap measured over a few hundred can be noise. |

The strict alpha level for the SRM test is a deliberate choice. A false alarm that your test is broken is more costly than a missed one, because it erodes trust in future results. If the holdout and wheel groups don't look like they came from the same traffic, the test flags it before you draw a conclusion from a corrupted comparison.

Finally, give the test time. A holdout run for a day catches a day's worth of traffic patterns. A full week (ideally several) averages out weekday/weekend and any one-off spikes.

## What to do with the answer

If the wheel is adding profit, that's your signal to leave it running and maybe test a second variable — a different prize mix, a different trigger — against the same holdout. If it isn't, the fix usually isn't "remove the popup," it's the odds. Profiter's recommendation engine flags common issues based on your store's data, such as:

- **A "no win" share below 20%:** You're discounting nearly every visitor who plays.
- **A jackpot probability over 1.5%** without a redemption limit set, creating margin risk.
- **Ignoring the Rule of 100:** If your average order value is over **$100**, fixed-amount discounts are usually safer than percentages. If it's under **$100**, percentages are often better. This is the fastest lever to check, and it's covered in detail in [a simple way to set fair wheel odds](/blog/rule-of-100-wheel-odds/).

Either way, you find out from a number grounded in your actual margins — not from a spin count that looked good in a screenshot.

---

### Why Spin-to-Win Popups Fail: Vanity Metrics vs. Real Profit

- URL: https://get-profiter.kraftpixel.com/blog/why-spin-to-win-popups-fail
- Category: Strategy
- Author: Abhishek Gharat
- Published: 2026-07-28

A spin-to-win popup can look like your best-performing marketing channel and still be costing you money every month. Thousands of spins. A signup rate your email list would envy. A steady stream of "15% OFF" codes going out the door. None of that tells you whether the popup made you a cent.

## Spins and signups aren't money

A spin is an impression. A signup is an email address. Both are easy to inflate — loosen the odds, shrink the form, and both numbers climb — without any guarantee the store is better off. The only number that reflects reality is what's left after the popup's costs: the discount given away, any free shipping absorbed, the margin on what actually sold.

That distinction matters because every prize a wheel can hand out costs something real. Percentage off and fixed-amount discounts cut straight into margin. Free shipping comes out of your shipping budget. A free gift costs you inventory. A wheel that's generous with all of these can rack up an excellent spin count while quietly bleeding money.

And shoppers can't game the system. On a properly built wheel, the prize is decided on the server the moment the spin starts, using the odds you set. The animation is just for show; the browser only learns which slice to land on after the result is already locked in. This prevents shoppers from manipulating the outcome, but it also means every single prize awarded is a real cost deducted from your margin according to plan.

## The failure mode: discounting sales you already had

Here's the part that doesn't show up in a spins-and-signups dashboard. A shopper who was already planning to buy at full price — a returning customer, someone who came straight from a product ad, anyone already sold — spins the wheel because it's there, wins 15% off, and claims it. The store just discounted a sale that would have happened anyway.

This is discount stacking on traffic that was already converting, and it's invisible if all you're watching is spins, signups, and codes redeemed. The causes, though, tend to follow a few predictable setup mistakes. These are the thresholds Profiter's recommendations engine actually checks a wheel against, and what each one is protecting you from.

| Rule | What goes wrong | Where the line sits |
|---|---|---|
| **Too few no-win slices** | If a win feels guaranteed, a shopper has every reason to spin and claim a discount they didn't need. | We flag a wheel whose "no win" share drops below **20%** of outcomes. |
| **High AOV + % discounts** | A 15% discount on a $250 order is a $37.50 margin hit. On big carts, percentages get expensive fast. | Above an average order of **$100**, we suggest switching to a fixed amount. Below it, we suggest the reverse. |
| **Risky jackpot odds** | A big prize drives the spin, but if it lands often with no cap, one traffic spike prices it into every order. | We flag a jackpot at **1.5%** probability or higher with no redemption limit set. |

Being straight about where those numbers come from: they're deliberate defaults we chose and hard-coded, not findings mined from a pool of customer data. What *is* verified is the maths they sit on — the measurement and recommendation modules carry 46 unit tests between them, with the normal and chi-square distribution functions checked against published reference values and critical-value tables rather than trusted because they looked right. Thresholds are a judgement call; the arithmetic underneath them isn't.

A wheel that breaks these rules is set up to discount sales you already had. Every one of those spins and signups goes up right along with the leak.

## Why it can look great while it's losing money

The reason this failure mode hides so well is that there's nothing to compare it against. A dashboard showing "spins are up this month" has no way of knowing what those visitors would have bought without the wheel. Comparing this month to last month doesn't fix it either — a sale, a traffic spike, or a seasonal bump can move both periods for reasons that have nothing to do with the popup.

Without a group of shoppers who never saw the wheel at all, there's no baseline. Every number the popup produces is measured against nothing, which means a store can watch spins and signups climb for months while the discounts handed out quietly erase the profit those numbers were supposed to represent.

## The fix is a number, not a vibe

Fixing this doesn't mean guessing at better odds or turning the popup off to see what happens. It means measuring profit per visitor for shoppers who saw the wheel against profit per visitor for a [holdout test](/blog/holdout-test-popup-profit/) — a slice of traffic the app deliberately excludes from the wheel so you have something real to compare against.

But for that comparison to be trustworthy, the mechanics matter. A split that holds up statistically has to guarantee three things:

1.  **Consistent Grouping:** A visitor must stay in the same group (either seeing the wheel or not) across multiple sessions. This is often done using a deterministic hashing algorithm like **FNV-1a** on a visitor ID, which requires no server state to remember the visitor's assignment.
2.  **Valid Traffic Split:** The holdout and test groups must be the right size. If you ask for a 10% holdout, you need to get a 10% holdout. A **Chi-square goodness-of-fit test** can run constantly in the background to verify this. A strict significance level (e.g., `alpha = 0.001`) is used to avoid false alarms that might cause a merchant to distrust a valid result.
3.  **Real Profit Measurement:** The final number can't be revenue. It must be **profit per visitor**, calculated after subtracting the cost of goods sold (from your margin) and the actual cost of discounts and shipping.

If the wheel group comes out ahead on that final profit-per-visitor number, the popup earned its keep. If it doesn't, the fix is usually the odds—using the thresholds above—not the popup itself. That's a much smaller decision to get right than reading a spin count and hoping.

---

### How to Stop Discount Code Abuse on Shopify

- URL: https://get-profiter.kraftpixel.com/blog/stop-shopify-discount-code-abuse
- Category: Security
- Author: Abhishek Gharat
- Published: 2026-07-28

A shopper wins 20% off on your wheel, posts the code to a coupon-sharing site that evening, and by morning a few hundred strangers have tried to redeem it. Or a shopper opens their browser's dev tools, edits what comes back from the popup, and lands on the jackpot slice every single spin. Both are the same underlying problem: something that should be decided and enforced on your server has instead been trusted to the shopper's browser.

## Why a wheel is a specific target for abuse

A spin-to-win popup makes two promises at once: the prize is picked fairly, and the code it hands out only works for the person who won it. If either promise is enforced client-side — the browser decides the outcome, or the same code gets reused for everyone — a shopper who knows how to open dev tools or a forum post that spreads a working code can break it. Neither requires much sophistication. Both just require the app to have left the decision somewhere the shopper can reach.

## Prize selection happens on the server, not in the browser

Profiter picks the winning slice on the server, using a cryptographically secure random number generator (a CSPRNG) and the odds and stock caps you set for that campaign. The browser never runs the odds calculation and never gets to choose — it receives the result the server already committed to, and its only job is to animate the wheel to a stop on that slice.

This server-side decision is designed to feel instant. A feature we call a "zero-dead-time spin" begins the wheel's wind-up animation while the request to the server is still in flight. This overlaps the animation with the network round-trip, so the shopper perceives no delay. Editing the page, replaying a request, or inspecting network traffic doesn't change which slice was picked, because the picking already happened somewhere the shopper's browser can't touch.

Building features like this without slowing down your store requires a strict performance budget. Every feature is weighed against the bytes it adds. Here is the actual history of our JavaScript budget for the wheel, showing what each increase paid for.

| Budget | What the extra bytes bought |
|---|---|
| 16 KB | baseline physics spin, clacker pointer, victory effects |
| 18 KB | themes + hub logo |
| 19 KB | post-win coupon reminder bar |
| 19.5 KB | first-touch source capture |
| 20 KB | zero-dead-time spin (wind-up overlaps the `/spin` round-trip) |
| 20.5 KB | latency failsafe: cruise spin while server is slow, animated `already_spun` replays |
| 21 KB | mint-failure recovery: "generating your code" bar + recover polling |

*Budget is for raw or gzipped JS, whichever is larger. Measured 28 July 2026 from the built extension assets.*

## Every win gets a unique, single-use code

The second half of code abuse is reuse: one code, shared or leaked, redeemed far more times than the one shopper it was meant for. Profiter doesn't hand out from a shared pool. To avoid API latency during the spin, codes are minted ahead of demand. Each win claims a pre-minted, single-use discount code via a Shopify Function, and that code is applied straight to the cart rather than typed in at checkout.

It's single-use by construction — good for exactly one redemption. If a shopper copies it and posts it somewhere before checking out, the first person to redeem it consumes it. Every attempt after that hits a code that's already spent.

## Are Shopify discount codes case-sensitive?

No, discount codes on Shopify are not case-sensitive. A code entered as `SAVE20` works the same as `save20`. This is a platform-level behavior, not specific to any app. It's another reason why simply creating a complex, hard-to-guess code isn't enough to prevent it from being shared and abused; technical enforcement is required.

## What this actually protects

Put together, the two mechanisms cover the two ways a wheel gets gamed. You can't force a better prize than the odds allow, because the browser never had the odds to begin with. And a leaked code doesn't turn into free discounts for a coupon forum, because there's no shared code sitting there to leak — only a pre-minted, one-time code already spoken for by the shopper who won it. Neither fix depends on the shopper behaving well. Both hold regardless of what happens in their browser, which is the only place a popup app can't fully trust.

---

### Klaviyo + Popup Sync: Turning Spin-to-Win Leads Into Email Revenue

- URL: https://get-profiter.kraftpixel.com/blog/klaviyo-popup-integration
- Category: Integrations
- Author: Team Profiter
- Published: 2026-07-28

> **Coming soon.** Klaviyo, Mailchimp and Omnisend sync is built and in final testing, but it isn't switchable inside Profiter yet. Everything below describes how it works when it ships. Real-time [Google Sheets sync](/google-sheets-integration/) is live on Growth+ today, and CSV export is on every plan.

A shopper spins the wheel, wins a prize, and hands over their email. From that second, a clock is running. The offer is fresh in their mind for maybe a day, maybe an hour. If that lead sits in a spreadsheet until your next weekly export, you've already lost the moment that made them want to buy.

That's the real cost of a CSV-based workflow. The data is fine. The timing is what kills it.

## What a CSV export can't do

A downloaded list is a snapshot. It tells you who spun the wheel last Tuesday, not who's spinning it right now. By the time you've exported it, cleaned it, and uploaded it to your email tool, the shopper has either bought, forgotten, or gone somewhere else. A welcome flow that fires three days after the event it's welcoming feels like an ad instead.

Klaviyo, Mailchimp, and Omnisend lead sync on Profiter's Growth+ plan ($29/month) closes that gap. Each lead reaches Klaviyo the moment it's captured, on whatever schedule the shopper sets rather than the one you remember to keep.

The sync is deliberately fire-and-forget: the spin never waits on a third-party API. If Klaviyo is slow or returns an error, the shopper still gets their prize, and the failure is recorded against the integration for you to see in Settings rather than thrown at the person spinning the wheel.

## Exactly which fields arrive in Klaviyo

Worth being precise, because "syncs your leads" hides a lot of variation between apps. A Profiter lead lands as a Klaviyo profile carrying:

| Field | What it holds |
|---|---|
| `email` | The address the shopper entered, when you ask for one |
| `phone_number` | Only when it's valid E.164 — Klaviyo rejects anything else, so we filter rather than let the profile fail |
| `first_name` | When your form collects it |
| `profiter_consent` | Whether the shopper actually ticked the consent box, which is never pre-ticked |
| `profiter_source` | First-touch acquisition source, as `utm:…`, `referral:…`, or `direct` |

*Source: the Klaviyo provider in Profiter's `esp/index.ts`, verified 28 July 2026.*

That `profiter_source` field is the one merchants tend to underuse. Because it's captured at first touch rather than at the moment of the spin, it survives a shopper wandering your site before they play. Segment on it and you can see whether the wheel is earning its keep on paid traffic specifically, or only converting people who were already coming to you direct.

## Why consent and double opt-in travel with the contact

Syncing consent status alongside the address matters for two separate reasons, and both cost you if you skip them.

The compliance reason is straightforward. Klaviyo and most email providers expect proof that a contact agreed to be emailed. A list built from a manual export, with consent recorded somewhere else or nowhere at all, is a gap that a spam complaint will eventually find.

The deliverability reason hits revenue harder. Inbox providers watch how a sending domain behaves — bounce rates, complaints, engagement on unconfirmed addresses — and that reputation is shared across everything you send. Push a batch of unconfirmed spin-to-win emails into a live flow and you're gambling with the domain your best customers' emails depend on. When double opt-in status arrives with the contact, Klaviyo's segmentation can hold sends back until someone has confirmed.

## How do I add a Klaviyo popup to Shopify?

A common point of confusion, and worth separating. Klaviyo ships its own popup forms. Merchants who want spin-to-win specifically tend to run a dedicated popup app alongside it, which gives the two tools distinct jobs:

1. **Profiter** lives on your storefront, captures the lead, picks the prize server-side, and mints the discount code.
2. **Klaviyo** receives the lead and runs the email or SMS flows that convert it.

The "integration" is the real-time sync connecting them. You install Profiter on Shopify for the popup, then connect Klaviyo so the leads go to work immediately.

## The code is ready before the email is

One source of delay sits outside the sync entirely: how the discount code gets made. Generating a fresh code at the moment someone wins puts a third-party API call between the shopper and their prize.

Profiter mints single-use codes ahead of demand instead. A win claims a code that already exists, and it's applied through the cart via Shopify Functions, so the discount is waiting at checkout without anyone copying and pasting anything. The shopper has their reward before your welcome email has finished sending.

## Measuring whether the flow actually earned anything

A synced flow can look healthy — good open rates, plenty of clicks — while the wheel behind it quietly loses money on discounts. Those are two separate questions, and Profiter answers the second one on every plan, including Free:

| Component | Implementation | What it's for |
|---|---|---|
| Holdout bucketing | FNV-1a 32-bit hash of visitor + experiment ID | Keeps a visitor in the same arm across sessions, with no server-side state |
| Significance | Two-proportion z-test, 95% Wald confidence interval | Says whether the gap between wheel and holdout is real |
| Split integrity | Chi-square goodness-of-fit at alpha = 0.001 | Flags a corrupted test before you draw conclusions from it |
| Profit | Profit per exposed visitor, from your margin and shipping inputs | Measures the bottom line after the discount was paid for |

*Source: Profiter's `stats.ts` and `experiments.ts`, verified 28 July 2026.*

If the flow converts well but profit per visitor barely beats the holdout, the fix is usually the prize odds rather than the email. [The holdout test](/blog/holdout-test-popup-profit/) covers how to read that comparison.

If you're running a spin-to-win popup and still exporting a spreadsheet into Klaviyo once a week, turning the sync on and retiring the spreadsheet is the whole fix — [see the Klaviyo integration](/klaviyo-integration/) for how it works.

---

### WhatsApp Marketing for Shopify: Turning a Coupon Win Into a Conversation

- URL: https://get-profiter.kraftpixel.com/blog/whatsapp-marketing-shopify
- Category: Integrations
- Author: Team Profiter
- Published: 2026-07-28

> **Coming soon.** WhatsApp prize follow-ups are built and in final testing, but they aren't switchable inside Profiter yet. Everything below describes how the follow-up works when it ships. Pro+ today covers unlimited spins plus Zapier, Make.com and custom webhook automations.

A single-use discount code doesn't wait around. It sits unused in an inbox tab a shopper meant to get back to, or in a popup they screenshotted and then lost track of. The prize was won in a few seconds on the wheel; the follow-up that reminds them to use it has a much narrower window to land.

Email is good at a lot of things. Urgency isn't one of them. A promotional message competes with dozens of others in the same inbox, and plenty of shoppers check that inbox once a day, if that. A phone stays in someone's pocket, and people tend to glance at a messaging-app notification within minutes — that's a general pattern in how messaging apps get used, not a figure specific to Profiter. For a code that's only good for a limited time, that gap in speed is the whole point.

## What actually happens after a win

Profiter's WhatsApp follow-up, on the Pro+ plan ($47/month), sends a message from the merchant's own WhatsApp Business account through Meta's Cloud API. The number the shopper sees is the merchant's own, and the message carries the prize and the code they just won.

The messaging app is only half of that speed. The other half is where the code comes from. Generating a fresh discount code at the moment someone wins puts an API round-trip between the shopper and their prize, and a slow response is felt as a stalled wheel.

Profiter mints single-use codes ahead of demand instead, so a win claims one that already exists. The code is applied through the cart via Shopify Functions, which means it's waiting at checkout without the shopper copying anything across. By the time a follow-up email would have finished sending, the WhatsApp message and a working code are already on the shopper's phone.

That matters for how the message reads on the other end. A text from an unfamiliar number gets ignored or reported. A message that shows up under a business name the shopper recognizes, right after they won something from that business, reads as service rather than spam. It's the difference between a stranger texting you a coupon and the store you were just browsing confirming what you won.

## What the opt-in step is actually protecting

Getting a WhatsApp follow-up working requires two things from the shopper: a phone number, and an explicit, unticked opt-in. Consent is never pre-ticked in Profiter's popup — the shopper has to actively check the box, the same standard applied to every other lead capture field in the app.

That step does two jobs at once. The compliance job is the obvious one: WhatsApp marketing runs through Meta's own business messaging rules, and sending to a number without clear opt-in puts the merchant's WhatsApp Business account itself at risk. The quality job matters just as much. A shopper who deliberately checked a box to hear from you on WhatsApp wants that message. A number collected without a real opt-in gets you a contact who's annoyed the first time you text them, and on WhatsApp, being annoyed means blocking the number outright rather than quietly unsubscribing from a list.

Explicit consent also means the merchant is building a list of shoppers who actively chose a more personal channel to hear from them — a smaller list than an email list, almost always, but one where the messages that do go out land somewhere the shopper is actually paying attention.

## How to measure if WhatsApp is worth the cost

Adding a paid channel raises a fair question: is it working? Profiter answers that with measurement included on every plan, from Free to Pro+. Turning WhatsApp on gives you a way to measure its effect against a real baseline rather than a hunch.

This is done with a holdout group. A small fraction of your store's visitors are held back from seeing the wheel at all, which gives you a true baseline for store performance. To keep a visitor in the same group across sessions without needing server-side state, Profiter uses a deterministic **FNV-1a 32-bit hash** of the visitor ID and the experiment ID. The comparison between groups is then read with a **two-proportion z-test and a 95% Wald confidence interval**, and the split itself is checked with a chi-square test at **alpha = 0.001** — deliberately stricter than the usual 0.05, because falsely telling a merchant their test is broken costs more than occasionally missing a real problem.

Worth being precise about what that measures: the holdout tells you what the *wheel* added, not what WhatsApp specifically added. Profiter doesn't run a separate holdout on the follow-up channel. If you want to know what WhatsApp itself is worth, the honest method is to run it for a defined period and then pause it for a comparable one, watching profit per visitor and code redemption across both windows — and give each window enough traffic to mean something. Profiter treats a result as reliable at **1,000 exposed visitors**; a channel test read over a weekend is noise.

## Why this beats a generic broadcast

The message that follows a spin is confirmation of something the shopper just won — the code attached, and, if the merchant sets it up that way, a nudge shortly before it expires. A broadcast blast talks at a whole list at once. This talks to one shopper about one thing they just did, which is exactly the kind of message a phone-based channel handles well: short, specific, timed to the moment it's actually relevant.

Email still carries the bulk of a merchant's follow-up on Growth+ through Klaviyo, Mailchimp, and Omnisend sync, and most winners will never opt into WhatsApp at all. WhatsApp adds a second channel for the subset of shoppers who'd rather get a text than dig through their inbox, and a faster path to the moment that turns a spin into a completed sale. A merchant running both ends up with email doing the volume and WhatsApp catching the shoppers for whom a text is what actually gets read before the code expires.

If you're running WhatsApp follow-ups already, or thinking about adding them, [see the WhatsApp integration](/whatsapp-integration/) for how the Meta Cloud API setup works.