For this case study, meet DontRing Doorbell: a lesser-known smart doorbell company, not to be confused with any better-known smart doorbell makers. They had a state-of-the-art face recognition model, and wanted to know whether a small, offline device could make sure it only ever saw pictures worth recognising.
The Challenge
Face recognition works brilliantly on a clear, well-lit photo of someone looking straight at the camera. Doorsteps rarely offer one, because delivery drivers are moving, visitors look anywhere but the lens, and it's often dark, raining or both.
Most face recognition systems fix this with a screen: you see yourself, adjust and try again. A doorbell doesn't have that luxury. It also has a small battery and can't rely on a network connection, so sending every blurry snap to a heavyweight model is wasted compute, poor results and a flat battery.
DontRing asked us to prove whether a compact edge camera could judge each image on the spot, before it reached the recognition model. If a picture wasn't good enough, the device should know why, so it could tell the person at the door what to do: "Move further back", "Take your helmet off", that sort of thing.
Our Solution
We built an end-to-end image pipeline that runs entirely on a Raspberry Pi 5. It captures images from the camera and checks their quality on the device, using TensorFlow Lite (a framework for running machine learning models on small hardware), before anything is passed to face recognition.
The heart of it is a gate. Rather than one big model deciding "good enough or not?", a set of small classifiers each answer one simple question:
- Is the image blurry?
- Is the person too close?
- Is the whole face in shot?
Simple questions are easier for a small model to learn, cheaper to run, and give a specific reason when an image fails. A specific reason is exactly what the device needs to tell someone how to fix it.
How We Built It
Our first approach trained a single model to predict pass or fail. The labels came from the recognition pipeline itself: images where recognition confidence cleared a threshold were a pass, everything else a fail. It was a good starting point, but it plateaued quickly. Darkness, distance, angle and obstruction were all being squeezed through one narrow gate.
Next, we built a lightweight validation model that looked at recognition confidence and image sharpness together, to judge whether a finished recognition attempt could be trusted. It caught a bad recognition 88% of the time. It also had a handy side effect: it could sort the obvious passes and fails automatically, which sped up labelling for everything that followed. But it only spoke up after the expensive work had already been done.
The final approach split the job into the separate blur, distance and framing classifiers described above. This made the problem far more learnable and matched the conditions the device actually faces on a doorstep.
To help the models cope with the real world, we grew the training set to around 61,000 images. It combined open-source data (the WIDER FACE dataset), Gemini-generated images, a small set of our own captures shot on doorbell hardware, and augmentation: cropping, rotating, flipping and adjusting brightness.
Getting a capable model onto a Raspberry Pi meant making it smaller without losing what matters. We used transfer learning (starting from a model that already understands images), quantisation (storing the model's numbers at lower precision, so it's smaller and faster) and a narrower network.
To know whether the gate was working, we needed a way to measure "good enough for recognition" without someone checking every image by hand. We used the recognition model's own confidence score, tested against an evaluation set, as a repeatable line to check every candidate model against.
Edge work usually means juggling different toolchains for each device. We used tooling like PlatformIO so we didn't have to rebuild the deployment process from scratch every time the hardware changed.
The Results
By the end of the project, DontRing had an offline image quality pipeline running on commodity edge hardware.
We measured the models using F1, a score that balances two mistakes: letting a bad image through and turning a good one away.
The project turned an open technical question into a working proof of viability. It showed that recognition gating works on the device without a network connection, and it pinpointed the main technical risks around image quality and real-time feedback.
It also gave DontRing a practical baseline for what comes next: a smaller footprint, a lighter power budget, and a route to rolling it out across the rest of their range.
Why It Matters
The real value of AI on the edge is timing. Put the decision on the device and the answer is instant, with no round trip to the cloud and no waiting for a signal.
There's a trade-off, of course. Edge AI is great wherever the cloud can't be relied on, but it only pays off if a small model can do the job nearly as well as the big one it's standing in for.
This project is that trade-off in practice: shrinking a recognition workflow to something a Raspberry Pi can run, without losing the accuracy that makes it worth having. Small models asking simple questions, tested on the real device, with deployment that survives a change of hardware. We think we got it, as Goldilocks would say, just right.
Where Else This Works
The doorbell is the example, but the pattern is everywhere: check the input is good enough before you spend power, time or money on the expensive model. And if it isn't, say why, so it can be fixed on the spot.
How It Could Help You
If you've got a model that works well in the lab but struggles with what the real world hands it, or a device a long way from a plug socket or a reliable signal, we'd love to hear about it.
For more edge work, see how we built computer vision on a battery-powered buoy for Pebl, or try it yourself with Recipe 2: Fashion on the Edge from our MLOps recipe book.
Get in touch at talk@fuzzylabs.ai or call 0161 533 0337.
.png)

.png)

.jpg)


