Fraud Looks Like a Typo: How We Stop Bad Actors Before They Reach the Road

Fraud rarely looks like fraud. It looks like a plate number that's one digit off, or a phone number that used to belong to someone else. Here's how Twende cross-checks every driver application, and why our machines flag while humans decide.

8 min read

Here are two plate numbers. One was typed by a driver into their application. The other was printed on the insurance certificate they uploaded.

AB 1234 CD

AB 1239 CD

Did you spot it on the first read? Most people don't. Most reviewers, at the end of a long queue, wouldn't either.

It might be nothing: a tired driver, a slip of the thumb. It might also be an insurance certificate that belongs to a different vehicle, borrowed to get an uninsured one onto the road. From the outside, those two stories look exactly the same.

That's the uncomfortable truth we kept running into while building Twende's driver onboarding: fraud rarely looks like fraud. It looks like a typo.

In Every "No" Needs a "Why", we wrote about making onboarding transparent: telling every driver exactly why a document was flagged and how to fix it. This is the other half of that story. Transparency is only safe if the checks behind it are strong. So here's how we catch the things that shouldn't get through, and the principles that keep us from punishing the honest drivers who make up the overwhelming majority.

Why fraud checks can't be an afterthought

A ride-hailing platform makes one promise before any other: the person who picks you up is who we say they are, driving the vehicle we say they're driving, with the papers we say they have.

Every passenger who gets into a Twende car or onto a Twende moto is trusting our onboarding pipeline with their safety. That's why we don't treat fraud as a separate team that cleans up afterwards. Fraud checks live inside the onboarding pipeline, and they run before a human ever makes a decision.

The threats we care most about aren't sophisticated. They're ordinary, and that's what makes them dangerous:

  • A banned driver coming back under a new name, with a new phone, hoping nobody connects the dots.
  • Borrowed or recycled documents: an insurance certificate from another vehicle, a licence that belongs to a relative.
  • One person, many accounts: several applications submitted from the same device, testing which one gets through.
  • Simple inconsistencies that hide a bigger problem: a plate, a name or a date that doesn't quite match across documents.

None of these needs a hacker. They need someone patient, and a system that only looks at one document at a time.

Layer one: read the documents, then compare them

The first layer works on a single application.

When a driver uploads their documents, our system reads them automatically. It extracts the key fields from each one, such as the full name, licence number, national ID number, plate number, make and model, registered owner, policy number and expiry dates. It then compares each field with what the driver typed in their application.

In the reviewer's dashboard, every extracted field appears next to the application data with a simple label: Match or Review. When something doesn't match, the reviewer sees both values side by side: what the document says, and what the application says.

That's how the plate number at the top of this article gets caught. A human eye skims past a single-digit difference. A field-by-field comparison doesn't.

It's also how we catch the slower kinds of trouble: an insurance policy that expires next week, a vehicle registered to someone other than the applicant, a licence number that doesn't match the one typed in the form.

Layer two: look beyond the application

The second layer is where most of the real fraud shows up, because it stops treating an application as a world of its own.

A single application can be perfectly consistent and still be a problem. A banned driver who signs up again with fresh documents won't trigger a single mismatch inside their own file. The only way to catch them is to compare the application with everything else we know.

So for every application, we run a set of automated cross-reference checks:

  • National ID cross-reference. Has this ID number appeared on a banned or rejected profile before, possibly under a different name?
  • Phone number cross-reference. Is this number linked to another profile, or was it previously associated with a banned driver?
  • Vehicle plate check. Is this plate already registered to another active driver?
  • Device fingerprint. Has this application come from a device that has also submitted other applications?
  • Account standing. Has this person been suspended or banned before?

Each check produces a short, readable result with one of three severities: Clear, Review or Alert. At the top of every driver's profile, the reviewer sees a one-line summary such as "4 of 5 checks clear · 1 flagged" before they open a single document.

Our view is simple: identity isn't a document, it's a graph. A name, an ID number, a phone, a plate and a device are all points that connect people to each other and to their history. Someone can replace any one of them. It's much harder to replace all of them at once.

Machines flag. Humans decide.

Here's the principle we care about most, and the one we think many platforms get wrong.

None of these checks rejects anyone automatically. A Review means "look at this carefully". An Alert means "look at this very carefully". In both cases, a person on our team makes the decision, with the evidence in front of them, and that decision is recorded with its reason in an audit trail.

We built it this way because in the markets we serve, the innocent explanation is often the most likely one:

  • Phone numbers get recycled. A number that once belonged to a banned driver may now belong to someone completely unrelated. A flag should prompt a question ("did this number change owners?"), not a verdict.
  • Devices get shared. Families share phones. Applications get filled in at a cousin's house, or with a friend's help at a phone repair stall. Two applications from the same device can be fraud. It can also be two brothers.
  • Names get spelled differently. The same person's name can appear one way on a national ID and another way on a licence, especially across languages and administrations. A name mismatch is a reason to look, not a reason to refuse.

An automated system that rejects on every signal would be fast, cheap, and unfair to exactly the people we're trying to bring onto the platform. Honest drivers would pay for the fraudsters' behaviour. We would rather spend a few minutes of human attention than lose a good driver to a false positive.

The machines do what machines are good at: reading every field, remembering every account and never getting tired. The humans do what humans are good at: understanding context.

Transparency without a playbook

We've argued that every "no" needs a "why". So a fair question is: if we explain every rejection, aren't we teaching fraudsters how to get through?

No, and the reason is a deliberate design choice.

The reasons drivers see describe their documents: the image is blurry, the document has expired, the information doesn't match, it's the wrong type of document. Those are all things an honest driver can fix. What drivers don't see is the list of cross-reference signals behind the scenes, how we combine them or which one fired.

That separation is the balance we're aiming for. Honest drivers get everything they need to fix their application. Bad actors don't get a map of our defences.

Fraud goes both ways

Drivers aren't the only side of the marketplace. Passengers can cause harm too, and the same thinking applies.

For passengers, we look at patterns over time rather than documents: repeated payment chargebacks, fraudulent fare disputes, unpaid cash trips, cancellation rates far above the norm, and several accounts linked to the same device. Each passenger gets a simple risk level (low, medium or high) with the specific reasons listed, so our team can see why, not just how much.

A driver who accepts a trip deserves the same confidence a passenger does: that the person on the other end is real, and is who they say they are.

Our opinion, stated plainly

If you're building any platform where strangers meet in the real world, such as ride-hailing, delivery, home services or rentals, here's what we'd tell you:

  1. Fraud looks like a typo. Compare every field, every time. Small mismatches are where big problems hide.
  2. Identity is a graph, not a document. Check each application against your whole history, not just against itself.
  3. Machines flag, humans decide. Automate the detection. Keep a person accountable for the decision, and record why.
  4. Design for the innocent explanation. Recycled numbers, shared phones and spelling differences are normal. Your system should ask questions before it reaches verdicts.
  5. Be transparent about the problem, quiet about the detection. Tell people what's wrong with their documents. Don't publish your defences.

Safety isn't a feature we add to the ride. It starts long before the first trip, at the moment someone asks to become a driver. Getting that moment right, firm with bad actors and fair to everyone else, is how a platform earns the right to be trusted on the road.

Ready to ride with Twende?

Join the waitlist and be among the first to experience safer, fairer transport in African cities.

Related posts