956 Members, Zero Redemptions: A Loyalty Program Bug (Simply Explained)

956 members. Zero successful redemptions.

That's the number that made my stomach drop.

I'd built a loyalty program for my DTC fashion brand here in San Diego. Customers earn points when they shop, then spend those points on future orders. Standard stuff.

Two months live. Nearly a thousand people signed up. And not one of them had ever successfully spent their points.

A Feature That Looked Alive But Was Dead

Here's what made this ugly. The feature didn't look broken.

When you opened the cart, everything was there. Your points balance showed up, and it was correct. Someone with 400 points saw 400 points. The "redeem" button was sitting right there, clickable. People were clicking it.

And nothing happened.

Think of it like a vending machine that lights up, shows the right prices, takes your money, and then never drops the snack. From the outside it looks perfectly healthy. But it has never once done the one job it exists to do.

A loyalty program with zero redemptions isn't underperforming. It's a corpse wearing a name tag.

I had 956 people who each decided they trusted my brand enough to come back and spend their points. Every single one hit an invisible wall. And my system kept telling me everything was fine.

The One Character That Killed It

The whole disaster came down to a single character. Let me explain it the way I'd explain it to you over coffee.

When a customer clicks redeem, the cart sends their account number to my system so it knows whose points to spend. Picture two employees passing a note across a desk.

The note that got passed was a plain number. Just the digits, like 123456789.

But my system was expecting that note to be wrapped in quotes, treated as text. The first thing it tried to do was tidy up the note (trim off any extra spaces). That tidying step only works on text, not on bare numbers.

So the moment my system received a number instead of text, it choked and stopped cold. Before it ever got to the part where it actually spends the points.

Every redemption died on the very first step. Every customer. Every time. For two months.

The fix was almost embarrassing. Tell the system "treat this note as text no matter what shape it arrives in." Two quotation marks and one small wrapper. That was the entire difference between a working feature and 956 frustrated customers.

Why Testing Said It Worked

Here's the question that should bother you. How did this pass testing?

It passed because of how we tested it. When we checked the feature by hand, we typed in the account number as text, wrapped in quotes. Text has that tidying step, so the test ran clean. Points came off. Everything worked.

But the actual cart sent a bare number. The test and the real world disagreed on one tiny detail, and nobody caught it, because the test never sent the shape the real cart sends.

This is the core trap with AI-built features, and it's worth sitting with.

AI writes code that works for the input it imagines, not always the input it actually gets. Ask AI to build the feature and test it, and it'll happily test with a clean, tidy version of the data, because that's what a reasonable person would type. Then the real world sends something subtly different, and the whole thing dies in that gap.

This isn't only an AI problem. Human engineers make the same mistake. But AI makes it faster, and it makes it while sounding completely confident.

The Vague Apology That Cost Me Two Months

Now here's the part that actually cost me money. It wasn't the bug itself. The bug was a one-line fix.

The expensive part was what the customer saw when it happened.

My cart had friendly messages ready for a handful of common problems. But it could run into about a dozen different problems. Anything outside that handful, including this one, fell through to a single catch-all message: "Something went wrong."

That message is a black hole.

A customer who hits it can't tell my support team anything useful, because there's nothing to tell. Support can't reproduce it. And I couldn't trace it, because the message thrown to the customer threw away the one detail that would have cracked the case in five minutes.

So the failure was perfect, in the worst way. The customer sees a vague apology and gives up. They don't complain, because what would they even say? My dashboard quietly reads zero. And nobody connects "redemptions are flat" to "one tiny detail is breaking everything."

I've come to believe this strongly: every "something went wrong" is a bug you've decided not to diagnose yet. It feels polite. It's actually expensive.

How I Finally Found It

I didn't catch this with some clever alarm. I caught it because the number was impossible.

The redemption rate wasn't low. It was zero. And zero is a completely different animal than low.

A real feature is messy. Some people redeem, some give up, some mistype. You expect a human mess. What you never expect, across 956 people over two months, is a flat zero. Zero isn't slow adoption. Zero means nothing is working at all.

So I went hunting. First I changed that useless error message to include the actual reason behind it. Now a customer screenshot tells me exactly what broke. Then I traced one real failed attempt, followed it straight to the source, and had the whole thing diagnosed in about twenty minutes once my system stopped hiding the evidence from me.

And while I was in there, I found a second bug I wasn't even looking for. The part that calculates how many points are actually spendable was returning roughly zero. So even if redemption had worked, the system would have thought every customer had nothing to spend. Two separate failures, either one fatal, both invisible.

That's the thing about going to look. You rarely find just one.

What This Costs You If Nobody's Watching

Let me put a price on this.

Two months of a dead feature on a real revenue driver. Loyalty programs bring customers back, and repeat customers are where the profit lives. 956 people tried to spend their points, hit an invisible wall, got a meaningless apology, and walked away trusting my brand a little less.

None of it raised an alarm. My dashboard stayed green the entire time the feature was failing every single user.

That's the real damage with AI-built systems shipped fast and never checked. Not dramatic crashes everyone rushes to fix. Quiet erosion. Something that looks alive on the surface and is dead underneath, costing you real money while everything appears fine.

The value I bring isn't just building features. It's knowing where the silent failures hide and going to find them before they cost you a season. I look first at the numbers that are suspiciously clean, the zeroes that should be messy, the error messages that explain nothing.

If you've shipped AI-built tools fast and you're not sure what's quietly broken underneath, that's usually where the recovered revenue is hiding.

Want to explore what AI could do for your business?

Book a free 30-minute strategy call. No pitch deck, no sales team, just a real conversation about your operations and where AI fits.

Book a Discovery Call