VsionRepo — repo

VsionRepo — Product Design & UX

VsionRepo.

End-to-end UX for an AI visual-dataset platform

VisionRepo by Averroes.ai centralises manufacturing images and video into searchable, AI-ready datasets, then lets a team train and deploy its own vision models from them. I led product design and UX end-to-end: the Repo → Dataset → Version → Model object model, ingestion and annotation, auto-labeling from a 40-image seed set, review and quality workflows, dataset analytics, and the design system holding it together.

Duration
—
Tools
Figma
Team
—
Year
2026

📋Overview

VisionRepo is the visual-data platform built by Averroes.ai for manufacturing teams. It centralises, annotates and organises images and video into searchable, AI-ready datasets — and then lets a team train and deploy its own vision models from that data without writing code.

I led product design and UX end-to-end: the object model the product is built on, the ingestion and annotation flows, the auto-labeling and model-building journeys, the review and quality workflows, the analytics surfaces, and the design system that holds it together.

👩‍💻Three users, one dataset

  • Quality & process engineersDomain experts. They know what a defect is; they do not know, and should not need to know, what a confidence threshold is.
  • Annotators and QA leadsHigh-volume, repetitive work measured in images per hour. Interface friction here is a direct cost.
  • ML engineers and data scientistsThey own model performance, and need dataset lineage, class balance and export formats to be exact.

These three read the same dataset through completely different mental models. Most of the design work was making one object model legible to all three without flattening it to the lowest common denominator.

⚡️Visual data is broken

Manufacturing generates enormous volumes of visual data and then loses it. The failure is not storage — it is that nothing about the data is addressable.

  • Data silosImages trapped on inspection machines, technician laptops and SD cards, with no unified access.
  • Manual analysisEngineers spend the bulk of their time searching for files rather than solving quality problems.
  • No traceabilityNo link from an inspection image back to a specific unit, so warranty and recall investigations stall.
  • Poor collaborationKnowledge lives in email threads and in individual expertise, not in a shared system.
  • Inconsistent labelingDifferent teams use different terminology, so data cannot be aggregated or trained on.
  • Limited accessRemote teams cannot reach critical visual data at the moment they need it.

“The data exists. Nobody can find it, trust it, or train on it.”

Framed as a design problem: make a dataset into an object a team can see, search, argue about and improve — then make the path from that dataset to a working model short enough that a non-specialist will walk it.

Before — Inspection Images Scattered Across Systems

🧠Design thinking, applied

  • EmpathiseSat with the actual sequence: inspection run, export to a folder, rename, email, re-label, lose. Watched where engineers gave up and started over.
  • DefineReframed from “we need a labelling tool” to “we need the dataset to be a first-class object with lineage”. Every later decision falls out of that sentence.
  • IdeateExplored the repo → dataset → version → task → model spine against competing structures organised by line, by date, and by model run.
  • PrototypeClickable flows for the paths that carry the product: first repo, first 40 labels, first auto-label run, first export.
  • TestPut annotators and engineers on the same prototypes and measured where they hesitated, not what they said they preferred.

🧭Information architecture

The spine is Repo → Dataset → Version → Task → Model. Every screen can answer four questions without navigation: what am I looking at, which version is it, who touched it last, and what was trained on it. Auto-tagging and metadata extraction keep that spine populated without manual filing, and Git-like versioning means a change to a dataset is a reviewable event rather than an overwrite.

Information Architecture — Repo, Dataset, Version, Task, Model

FLOW 01

Seamless Integration — getting data in

Nothing happens until the data arrives, so ingestion is the first-run experience, not a settings page. Connectors for Google Drive, OneDrive, SharePoint, Dropbox, Box, S3 and local folders are presented as one row of equal choices, and the same picker appears wherever a dataset can grow. Multi-source imports reconcile into one repo, with duplicates and unsupported formats surfaced as a reviewable list rather than a failure dialog.

Connector Picker — First Run
Import Reconciliation

FLOW 02

Visual Data Labeling — the annotation canvas

The canvas is keyboard-first: select class, draw, confirm, advance, without leaving the home row. Bounding boxes, polygons, keypoints and pixel-level segmentation share one interaction grammar, so moving between defect types does not mean learning a new tool. Batch labelling handles the repetitive runs where the same call applies to hundreds of frames.

Annotation Canvas — Classes, Tools, Review State

FLOW 03

Image & Video Annotation — time as a dimension

Video turns labelling into a timeline problem. Frame labelling and object tracking are designed as one continuous motion: label once, let tracking carry the object forward, and correct at the frames where it drifts. The correction points — not the frames the model already has right — are what the interface puts in front of the annotator.

Video Timeline — Frame Labelling
Object Tracking — Drift Correction

FLOW 04

Auto Labeling — 40 examples, then the rest

The product's sharpest idea needed the clearest flow: label roughly forty examples per class, train a few-shot model, and let it annotate everything else. I designed it as four unmistakable steps — upload, label a seed set, build, auto-label — with progress toward the seed threshold shown as the primary signal, so the user always knows how close they are to the payoff.

The output is a review queue, not a result. Predictions arrive ranked by uncertainty, so the human reviews the shakiest first and can accept the rest in bulk. That single ordering decision is what makes a 100,000-image dataset reviewable.

Auto-Labeling — Seed Progress and Review Queue

FLOW 05

AI Labeling at Scale — review and assignment

At volume, labelling is an operations problem. Work routes by skill, balances across workload and respects a priority queue; a label then moves through initial annotation, peer review and QA approval, with quality gates between stages. The QA lead's view is built around throughput and agreement, the annotator's around the next item — same pipeline, two different surfaces.

Smart Task Assignment
Multi-Stage Review — Gates

FLOW 06

AI Builder & Vision Models — no-code training

Create, upload, label, train, deploy — one linear spine, each step blocked until the previous one is genuinely ready, with the blocking reason stated in domain language (“this class has 12 of the 40 examples it needs”) rather than as a disabled button. Classification, detection and segmentation are a choice of task made early and carried visibly through the rest of the flow, because that choice changes what the labelling canvas and the metrics mean.

AI Builder — Create, Label, Train, Deploy

FLOW 07

Dataset Quality Insights — trust before training

A model is capped by its data, so the dataset needs its own diagnostics: class balance, inter-annotator agreement, disputed labels, coverage gaps and drift between versions. These are framed as actions rather than statistics — every weak signal links to the exact slice of images that caused it, so “your data is imbalanced” becomes “label these 60 images next”.

Dataset Health — Balance, Agreement, Drift

FLOW 08

Data Analytics — from dataset to decision

The analytics surface answers the question the plant actually asks: what changed, where, and is it getting worse. Defect-rate and yield trends sit per line and per shift, with spikes called out as events rather than left for the reader to spot in a chart, and every number drills back to the images behind it. Export and BI integration carry the same figures into the dashboards the business already runs on.

Quality Trends — Lines, Shifts, Anomalies

FLOW 09

Golden Board Inspection (PCBA) — reference versus unit

PCBA inspection compares a board against a known-good golden reference, which is a comparison UI before it is anything else: aligned side-by-side views, a synchronised zoom, difference highlighting, and per-region tolerance that an engineer sets in terms of the board — pads, solder joints, component placement — rather than in pixels. A flagged difference carries straight into the same review and correction flow as every other defect, so the operator never changes tools mid-judgement.

Golden Board — Aligned Comparison
Region Tolerance — Pads and Joints
VisionRepo — Annotation, Datasets, Models

🧩Built for data-dense interfaces

Dense tooling punishes inconsistency, so the component library carries the weight: tokens for the whole surface, data-display primitives, canvas controls, queue and table patterns, and a defined state for every one of loading, empty, partial, conflicted and error. Two conventions do most of the work — confidence is always expressed the same way wherever it appears, and every destructive or irreversible action on a dataset is reversible through versioning.

Component Library — Primitives
States — Empty, Partial, Conflicted

📊What shipped

  • A dataset with lineageRepo, dataset, version and model are first-class objects, so visual data is searchable by serial number, defect type, date range or visual similarity instead of by filename.
  • Seed-set labelling as the main pathLabel around forty examples per class and the platform annotates the rest — published as 10x faster labelling, with review ordered by model uncertainty.
  • An operations layer around labellingSkill-based routing, multi-stage review and quality gates, with inter-annotator agreement tracked as a first-class metric.
  • No-code model buildingClassification, detection and segmentation trained and deployed from the same spine, by the engineers who own the quality problem.
  • Analytics that drill back to imagesTrends per line and shift, anomalies surfaced as events, every figure traceable to the frames behind it.

🌟Rank the work, do not just present it

Auto-labelling only pays off if a human can review thousands of predictions. Ordering that queue by model uncertainty — and letting the confident remainder be accepted in bulk — did more for throughput than any change to the canvas itself.

✨Name the objects before drawing the screens

Once repo, dataset, version and model were named consistently, most navigation questions answered themselves. The structural decisions carried far more weight than the surface ones.

🔍Translate the model, do not expose it

A process engineer should never meet a raw probability. Confidence belongs in the interface as a banded signal tied to the decision it implies, in the language of the board, the line and the defect.