I Built a Fake Review Detector in 30 Minutes (Then Almost Ruined It By Trying to Make It Perfect)

The Opportunity I Spotted

You know the drill. You're shopping on Amazon. Product has 4.5 stars and 2,000 reviews. Looks legit.

Then you actually READ the reviews:

"AMAZING PRODUCT!!! BEST PURCHASE EVER!!! LOVE LOVE LOVE!!! 5 STARS!!!"

"This product exceeded my expectations in every way possible. The quality is unmatched and the customer service was phenomenal. Highly recommend to everyone!"

"Received this item for free in exchange for my honest review. It's great!"

You can FEEL the fake radiating off the screen.

But which ones are actually fake? And more importantly - when YOU'RE doing competitor analysis or evaluating products to resell, how do you know which reviews to trust?

I needed a tool. So I built one.

Before Building: The Business Case

Past-me would have gone down a rabbit hole:

1. Research for days on "how to detect fake reviews"
2. Read academic papers on linguistic analysis
3. Build a dataset of 10,000 labeled reviews
4. Train a machine learning model
5. Obsess over accuracy metrics
6. Get overwhelmed
7. Abandon it
8. Keep manually guessing which reviews are fake

Months of work. Zero results.

This time was different. I spent 10 minutes researching, then built it.

What I Actually Built

10 minutes of research:

• Googled "common fake review patterns"
• Found 2-3 articles on detection methods
• Made a list of obvious red flags

15 minutes of building:

• Hardcoded 12 red flag patterns into a JavaScript object
• Simple text scanner
• Scoring system (0-10+ scale)
• Suggested authenticity markers
• Basic copy/paste interface

10 minutes of testing:

• Found sketchy Amazon products
• Pasted real reviews
• Watched it work

Total: 35 minutes. From idea to working tool.

Build Time: 35 minutes (10 min research + 15 min build + 10 min test)
Tools Used: JavaScript, HTML
Cost: $0

The 12 Red Flags I Hardcoded

I didn't need machine learning. I just needed to catch the obvious patterns:

Enthusiasm Red Flags:

• Excessive exclamation marks (3+)
• ALL CAPS sections
• Extreme praise without any specifics

Generic Language:

• Vague phrases like "exceeded expectations"
• No specific product details
• Marketing/promotional speak

Suspicious Patterns:

• "I received this product for..." (incentivized review disclosure)
• Suspiciously short (<20 words)
• Suspiciously long (>300 words)
• Avoids first-person pronouns (distancing)
• Only positives, zero drawbacks mentioned
• Excessive word repetition

Plus 5 authenticity markers (good signs):

• Mentions both pros AND cons
• Includes specific product details (dimensions, colors, features)
• Provides personal context ("I bought this for my dog")
• Compares to alternative products
• Reasonable length (not too short, not too long)

That's it. No AI. No machine learning. Just pattern matching.

What Worked, What Broke

I found a sketchy-looking product on Amazon (one of those "as seen on TV" gadgets with suspiciously perfect reviews).

Review #1: "THIS IS THE BEST PRODUCT I'VE EVER BOUGHT!!! AMAZING QUALITY!!! EVERYONE SHOULD BUY THIS!!!"

My tool's verdict:

• 🚩 Excessive exclamation marks
• 🚩 ALL CAPS abuse
• 🚩 No specific details
• 🚩 Only positives, no drawbacks
• Score: 8/10 - "Almost Certainly Fake"

Review #2: "I bought this for my kitchen counter and it's been great so far. The size is perfect for small spaces (about 8 inches wide). Only issue is the suction cups aren't super strong, so I wouldn't use it for anything heavy. For the price though, pretty good value."

My tool's verdict:

• ✓ Mentions pros and cons
• ✓ Specific product details (dimensions)
• ✓ Personal context (kitchen counter use)
• ✓ Reasonable criticism (suction cups)
• Score: 1/10 - "Likely Real"

It worked.

Even caught patterns I didn't explicitly program for - like the combination of specific details + balanced feedback = probably authentic.

The Perfectionism Trap (Again)

After seeing it work, my brain did the thing:

"Okay but it has false positives. That second review about suction cups could still be fake."

"What if we added more patterns? More red flags?"

"Shouldn't we validate this against a labeled dataset?"

"This needs refinement before I can ship it."

There it is. The trap wearing a new costume.

Not "this doesn't work" - it clearly worked.
Not "this isn't useful" - it caught fake reviews.
But "it's not PERFECT enough."

False positives exist. Yeah, obviously. It's a 15-minute build using hardcoded patterns. It's not going to be 100% accurate.

But you know what? It's still WAY better than my previous method of "just guess based on vibes."

The Reality Check

Here's what my AI co-founder said:

"Better research upfront = better first build. But 'works but has false positives' is not a reason to not ship. Every spam filter has false positives. Gmail has false positives. You're holding v1.0 to v10.0 standards."

Ouch. True.

I was about to delay shipping a working tool because it wasn't academically validated.

What I'm Learning (Again)

The trap keeps appearing. Different disguises each time:

Project 1: "This looks ugly" (design perfectionism)
Project 2: "Not impressive enough" (engineering perfectionism)
Project 3: "Has false positives" (accuracy perfectionism)

All the same trap. Just wearing different masks.

The pattern:

1. Build something
2. It works
3. Find a reason it's "not good enough"
4. Almost don't ship it
5. Get called out
6. Ship it anyway

I'm getting faster at catching it. That's progress.

The Research Win (Unexpected)

Spending 10 minutes researching BEFORE building actually helped this time.

Instead of winging it and building garbage, I spent 10 minutes learning what patterns actually matter. Then built based on that knowledge.

Result: Better first build. Fewer "oh shit I need to rebuild this" moments.

The balance: Research with clear criteria = good. Research without end point = trap.

Should You Actually Build This?

This stays as-is. 12 red flags, 5 authenticity markers, basic scoring.

Could it be better? Sure.
Does it need to be better to be useful? No.

It catches fake reviews better than eyeballing it. That's the bar.

If I use it 5 times and it helps me avoid buying fake-reviewed products or spot competitor manipulation? Worth the 35 minutes.

If I never touch it again? Still learned the research→build→ship cycle faster than last time.

Either way: shipped.

Build Time: 35 minutes total
Red flags programmed: 12
False positive rate: Probably 20-30%
Accuracy compared to guessing: Way better
Shipped anyway: Obviously

Bottom Line: Working with false positives beats perfect but imaginary. Even Gmail has false positives. Ship the 35-minute version instead of planning the perfect academic version.