Computer vision quality inspection · Image recognition systems
Image recognition trained on generic photos cannot tell your product from the reject bin
Banao builds image recognition systems trained on your actual production images — the good parts, the borderline cases, and the failures your line produces — so the classifier grades what comes off your machines, not what a benchmark dataset looks like.
We own the full build: annotation, model training, edge deployment, line integration, and the re-training loop that stops accuracy from sliding as your product mix changes. You get a system that identifies, classifies, and routes — not a model you have to wire up yourself.
RAK Ceramics— computer-vision image recognition deployed on a live ceramics production line in the UAE.
What a Banao image recognition system does on your line
An image recognition system in production is the model, the training data, the hardware, and the re-training loop — we build and own all of it.
Product and SKU classification
Models that identify which product, variant, or size is in frame — distinguishing your full catalogue by visual features, not a barcode that is missing or damaged.
Multi-class defect grading
Beyond pass or fail — a graded classification that separates a cosmetic scratch (rework) from a structural crack (scrap), so each reject goes to the right place.
Label, artwork, and print verification
Image recognition that reads the label against the specification: right artwork, correct orientation, no print defects, no missing elements — before the unit is packaged.
Assembly completeness identification
Recognition that confirms every component is present, in the correct position, and the right part — before the sub-assembly moves downstream.
Brand, region, and code reading
Combined recognition and OCR on date codes, lot numbers, and regional compliance markings — the data your traceability system needs, pulled from the camera, not typed by hand.
Training on your production images
We annotate your line images, not a public dataset. The classifier learns the specific texture of your tiles, the colourway of your packaging, the thread pattern of your fasteners.
Edge deployment with sub-second latency
Models run on edge hardware at the camera — no round-trip to a cloud API — so the recognition result arrives inside the window your line speed allows.
Continuous re-training on production data
As your product mix or line conditions change, we re-train on fresh production images and redeploy — so accuracy does not decay as your catalogue grows.
Why a general-purpose classifier fails on your production floor
Image recognition models trained on public datasets learn to distinguish between categories that matter on the internet — they have not seen the difference between a first-quality tile and a B-grade one, because that distinction lives in your factory, under your specific lighting conditions, in your specific product.
A manufacturing image recognition system has to be trained on images from your line. The annotation has to match your grading standard. The edge hardware has to deliver the result inside your line's inspection window. Skipping any one of those produces a demo, not a production system.
Annotation to your standard, not a generic schema
We work with your quality team to define the annotation schema — which mark is cosmetic, which is structural, which is a rework candidate — and apply that standard to your images, not a taxonomy borrowed from another industry.
Trained on the hard cases, not just the clear ones
Most defects a model sees in production are ambiguous. We collect and annotate the borderline images — the B-grade parts a human inspector might wave through — so the classifier learns to handle them, not just the easy pass and the obvious fail.
Performance measured on your production distribution
Before go-live, we evaluate against a held-out set drawn from your actual line, not a balanced benchmark. Accuracy is reported on the failure modes that matter to your process: missed defects, wrong-class routing, false rejects.
From camera to classification inside your line's inspection window
A classification result that arrives 800ms after the part has moved on is useless. The whole integration — camera, lighting rig, edge device, and model serving — has to fit inside the mechanical window your line speed gives to inspection, whether that is 200ms or two seconds.
We profile the line before we size the hardware. Throughput, unit size, inspection angle, and lighting conditions determine the camera specification, the illumination design, and the inference hardware — in that order. The model architecture follows the hardware budget, not the other way round.
Camera and lighting specified for your defect type
The same crack that is invisible under diffuse light appears under raking light. We specify the illumination geometry for your defect type — coaxial for surface finish, structured light for dimensional checks, backlight for silhouette — so the camera captures what the model needs to see.
PLC and line-control integration included
The classification output feeds your reject signal, pass gate, or sorting diverter — wired to the PLC or line controller you already run, so the result acts on the line without a manual step between the camera and the hardware.
We run image recognition on our own operations before we ship it on yours
InterviewGod — the hiring tool Banao developed and runs across its own ~300-person engineering operation — uses document and image recognition to process applications: extracting structure from CVs, reading portfolio attachments, and grading submissions before a recruiter opens the queue.
Building image recognition we stake our own hiring on is a different standard from shipping a model and walking away. The precision and recall that matter to us are the ones we measure on our own data, every week.
- InterviewGodUses document image recognition on every Banao hiring cycle.
Where we build image recognition systems
India
Bangalore and Chandigarh hold the annotation and engineering bench, so we can run large-scale image labelling campaigns and model training at the speed and depth a production system requires, under the DPDP Act.
UAE
From Dubai we build for GCC manufacturers and keep training data inside UAE boundaries where the PDPL and client data-residency policy require it. RAK Ceramics is a live reference in this region.
UK and US
For UK and US clients we build to UK GDPR and SOC 2 expectations, with documented data lineage from the annotation dataset through to the deployed model — required by the risk teams at most enterprise manufacturers.
When you do not need a custom image recognition system
Custom-trained image recognition is the right call less often than vendors imply. We will tell you before you commit a budget:
- An off-the-shelf vision platform already covers your defect types: configuring a commercial system is faster and cheaper than training from scratch if the product and failure modes are already in the platform's coverage.
- Your production volume is too low for a training set: a model trained on fewer than a few hundred annotated examples per class produces unreliable results — we would rather tell you that up front than ship something that fails on the line.
- The rejects trace to a process parameter, not a visual attribute: if most of your failures come from temperature, pressure, or feed-rate variation, a process sensor is a more direct fix than a camera system.
- Lighting and line speed make clean capture impractical: some geometries and throughput rates cannot be imaged reliably. If the physics do not work, we say so in the scoping call, not after the build.
How we start — prove the recognition task before we build the system
We do not quote an image recognition build from a brief. We test the classification task on your images first.
- AI Discovery Sprint2 weeks · fixed price
We collect a sample of your production images, annotate them to your grading standard, train a proof-of-concept classifier, and measure precision and recall on your hardest cases. You receive a feasibility report, an annotation plan, and a build specification — yours to keep regardless of next steps. If you proceed, the Sprint fee is credited against the build.
- Build
Full annotation campaign, model training and validation, edge hardware specification, camera and lighting rig, PLC integration, and a production evaluation report. Integration and end-to-end testing are deliverables, not add-ons.
- Production and re-training
We deploy behind a monitoring dashboard, track false-reject and miss rates on live production data, and run scheduled re-training cycles as your product mix or line conditions change.
Frequently asked questions
What is an image recognition system in a manufacturing context?
A software and hardware system that takes camera images of units on a production line and classifies each one — by product type, defect grade, label correctness, assembly state, or any other visual attribute — and feeds that classification to your line control to pass, reject, or route the unit without a human step.
How is image recognition different from defect detection?
Defect detection is a binary or multi-class task focused on pass or fail. Image recognition is broader: it includes classifying what the part is, which variant it is, whether the label is correct, and which defect category applies — not just whether a defect is present. In practice, a production system often uses both together.
How much training data does a custom model need?
A reliable classifier typically needs several hundred annotated examples per class, with the hardest class — often borderline defects — requiring the most images. The Discovery Sprint is designed to assess your existing image library and tell you exactly how many annotated images per class are needed before you commit to a full annotation campaign.
Can you integrate with our existing cameras and PLC?
Often yes. We assess your existing camera hardware in the scoping call. If the resolution and frame rate are adequate for your unit and line speed, we integrate the recognition system with your existing equipment. Where hardware needs upgrading, we specify exactly what is needed and why before any cost is committed.
How do you handle accuracy drift when the product mix changes?
We build a monitoring dashboard that tracks false-reject rate and miss rate on live production data. When drift is detected — or when you add a new product variant — we run a targeted re-training cycle on fresh annotated images from your current line, validate before deployment, and redeploy without taking the system down.
How long does it take to build and deploy an image recognition system?
The Discovery Sprint is two weeks and produces the feasibility assessment and build specification. A typical build — annotation, training, hardware, integration, and testing — runs eight to fourteen weeks depending on product complexity and the number of classes. Line integration and testing are included in the build timeline, not added at the end.
Do we own the trained model and the annotation data?
Yes. The trained model, the annotated image dataset, the training and evaluation code, and the deployment configuration are all yours at handover. You are not dependent on Banao to re-train or redeploy — we document the re-training process so your team can run it.
What industries have you built image recognition systems for?
Our computer vision work spans ceramics and tile manufacturing, consumer packaging, industrial components, and safety compliance monitoring. The annotation schema, defect taxonomy, and hardware specification differ by industry — we size each system to the specific product and line, not a generic template.
Bring your line images and your hardest classification case
In 45 minutes we will tell you whether a custom image recognition system is the right call — and what a production-grade build would take.
Book a 45-min scoping call