Can You Trust Your Field Photos? Catching the "Photo of a Screen" Trick
Every inspection program quietly assumes the photo is real. We built a lightweight detector that catches staged re-captures about 90% of the time, runs on an ordinary CPU, and is trained by your own operators, not data scientists.
The quiet assumption behind every inspection program
Field inspection runs on trust. When a technician uploads a photo of a junction, a meter, a splice, or a serial number, your whole process assumes one thing: that the picture is a real, first-hand capture of the actual asset, taken on site, right then.
Most of the time, that assumption holds. But it is an assumption, and the moment it slips, everything downstream slips with it. Compliance records, quality scores, payment approvals, and audit trails all inherit the trust you placed in that single image. If the photo isn't genuine, none of it means what you think it means.
The recapture trick: photographing a screen instead of the asset
Here is the simplest way to game a photo-based inspection: don't go to the asset at all. Pull up an old, approved photo on a laptop or another phone, and take a picture of that screen. The upload looks like fresh fieldwork. The timestamp is current. The image passes a quick human glance.
We call this a recapture, a photo of a photo. It defeats the entire point of requiring evidence, and it is almost impossible to catch reliably by eye at scale. When a reviewer is clearing hundreds of submissions a day, a slightly soft, slightly glare-flecked screen shot rarely stands out.
A detector your operators train, using a simple review queue
Working with field-inspection photos from a telecoms customer, we set out to catch recaptures automatically. The key decision was about who generates the training signal. We didn't bring in a data-science team to hand-label a dataset. Instead, operators flagged suspicious images through a simple in-app review queue, the same kind of queue they already use to sanity-check submissions.
Every flag became a labelled example. Genuine captures and staged screen shots accumulated naturally as part of normal review work. That's the ground truth the model learned from: produced by an operations team doing its day job, not by specialists writing annotation guidelines.
The people who know the work generated the labels. No data scientists required.
The result: about 90% of staged photos caught, 1.8% false alarms
On held-out photos the model had never seen during training, the detector caught about 90% of staged recaptures while raising a false alarm on only 1.8% of genuine photos. In plain terms: it flags the overwhelming majority of fakes while rarely bothering your team about a real one.
That balance matters. A detector that screams at everything is just noise your reviewers learn to ignore. Catching roughly nine in ten staged photos while keeping false alarms under two percent means the flags are worth acting on, a reviewer can trust that a flag deserves a second look.
About 90% of staged photos caught, with false alarms on just 1.8% of genuine ones.
What a 0.987 ranking score actually means
There's a second number worth understanding, because it's easy to misread. The detector earned a ranking score (ROC-AUC) of 0.987, up from 0.85 for the previous hand-tuned approach, and it held at 0.973 under a stricter, leakage-resistant validation that's harder to fool.
ROC-AUC measures how well the model sorts suspicious photos from genuine ones. A score of 0.987 means that if you hand it one staged photo and one genuine photo, it ranks the staged one as more suspicious about 98.7% of the time. That is not the same as saying it classifies 98.7% of photos correctly; it's a measure of ranking, of putting the right images at the top of the suspect list. The real-world catch rate is the 90% figure above. We separate the two on purpose, because conflating them would overstate what the tool does.
Runs on a normal CPU, no GPU farm, no consultants
Just as important as the accuracy is the cost of running it. The detector runs entirely on a commodity CPU at roughly 0.3 seconds per image, an illustrative figure from our own setup that will vary with your hardware. There is no GPU farm to provision, no specialist hardware, and no per-image inference bill that grows with your volume.
It also doesn't require constant retraining to stay useful. You can fold it into your existing upload-and-review flow as a quiet check that scores each photo as it arrives, escalating only the ones that look staged. The infrastructure you already have is enough.
Why honest stress-testing makes the number trustworthy
It's easy to publish a flattering benchmark. It's harder, and more honest, to test the way reality will. That's why we report results on data the model never trained on, and why we ran a stricter validation designed to resist the kind of leakage that quietly inflates scores.
We're also candid about the limits. The set of staged examples we tested against skews toward curated and synthetic recaptures, so we say 'caught about 90% of staged photos in our testing' rather than promising a fixed number for every program. Your environment, cameras, and the creativity of the people gaming the system will all shift the real-world rate. We'd rather tell you that up front than hand you a figure you can't rely on.
How this fits the Forge model: your team improves it
This is exactly what Forge by SkillsBase is built for. The recapture detector wasn't crafted by researchers in a lab, it was trained on real field-inspection imagery, labelled by the operators who live with the problem, and deployed to run on ordinary hardware. That's the whole promise: build your own AI, no code required, with the people you already have.
Trust and data integrity are now part of what your team can build for itself. If field photos are the backbone of your compliance and quality programs, a detector that flags the 'photo of a screen' trick is the kind of safeguard you shouldn't have to outsource. Talk to us about running a pilot on your own inspection photos.
How we measured this. Figures come from testing on held-out field-inspection photos the model never trained on, measured both on a standard split and under a stricter, leakage-resistant validation. The "about 90% caught" figure is honest about a known limitation: the set of staged examples skews toward curated and synthetic re-captures, so real-world rates will vary by program. Ground-truth labels were produced by operators flagging photos in a simple in-app review queue.