VISIONROUTE

Guide · Pillar: Prove

Twelve questions before you build image recognition.

A computer-vision use case is ready to evaluate when you can state the visual decision in one sentence, produce real positive and negative examples, price both failure directions, and bound variability, volume, latency, and privacy. The twelve-item checklist below turns that into a readiness check with a scoring rule. Whatever you cannot answer is not a blocker — it is your evidence-collection list, and it is shorter than a rebuild.

Published August 31, 2026 · Pillar: Prove · By the VisionRoute team

Definitions

Feasibility testing

Computer-vision feasibility testing is the process of determining whether a proposed visual decision can meet defined accuracy, latency, cost, and deployment requirements on representative data — before a full system is built. This checklist is the step before that test: it checks whether the test itself can be run honestly.

What passing means

Passing the checklist does not mean the use case is feasible. It means you can now find out — cheaply and defensibly. Feasibility itself is settled by testing, and the honest outcomes include "not yet feasible" and "not enough evidence".

Who this is for

Product engineers, founders, and engineering leads scoping an image-recognition feature — and the domain expert who owns what "correct" means. Items 1–3 are theirs more than yours.

How to use it

Download the markdown version below, paste it into your project doc, and answer in writing. Vague answers count as unchecked — the checklist works by refusing to be hand-waved.

The checklist

Four groups, twelve checks

The decision (1–3)

  • 1. The visual decision fits in one sentence.

    "Given [image], decide [answer], and the product does [action]." If the sentence needs "and also…", you have two use cases — run the checklist twice.

  • 2. Both failure directions have a named cost and owner.

    What happens on a false accept, what happens on a false reject, and who feels each. If nobody can price the failures, nobody can set the accuracy bar.

  • 3. A person can make this decision from the image alone.

    Show ten images to two domain experts separately. If they disagree, the project has a definition problem before it has a model problem.

The data (4–6)

  • 4. You have — or can collect — 100+ representative images.

    Including hard cases and true negatives, from the real capture conditions. Screenshots of other people’s datasets do not count as your distribution.

  • 5. Every example has a recorded expected answer.

    Ground truth written down before testing, not recalled during it. Disagreements surfaced by item 3 get resolved here.

  • 6. Variability is bounded and rare-but-costly cases are listed.

    Camera sources, lighting, resolution, occlusion — and the specific rare inputs whose failure would be expensive. If you cannot list them, collect until you can.

The constraints (7–9)

  • 7. The accuracy bar is stated per failure direction.

    For example: "false accepts under 2%; false rejects may go to review." A single overall accuracy number hides the direction that hurts.

  • 8. The latency budget is known — and where it binds.

    Synchronous user flow or asynchronous batch? The same model can be right for one and disqualified for the other.

  • 9. Volume is projected and priced at 12 months.

    Images per day now and at 12 months, and the per-image budget at that volume. Approaches that work at 1,000/day can stop making sense at 50,000/day.

The operations (10–12)

  • 10. Privacy and residency constraints are decided.

    May images transit a third-party API at all? Under which retention and training-use terms? This single answer removes or admits entire solution families.

  • 11. The abstention path is designed.

    When the system is unsure: human queue, safe default, or block? "It will always be sure" is not a design.

  • 12. Someone owns correctness over time.

    Models, providers, and your own product drift. Name who re-checks the decision when they do, and what triggers the re-check.

Computer-vision feasibility checklistThe twelve items with scoring rule, as plain markdown — free to copy, adapt, and commit to your repo.Download ↓

The scoring rule

How to read your score

Score with written answers only — an item answered from memory in the meeting is not yet a check.
Checks passingReadingNext step
10–12Ready to evaluate. The remaining gaps are known and small.Run a controlled test on your representative set — the checklist answers become the evaluation design.
7–9Promising, but the evaluation would be built on guesses where items are open.Close the specific open items first — usually data collection (4–6) or an unpriced failure direction (2, 7).
0–6Not a modeling problem yet. The use case is underdefined, and any demo would be unfalsifiable.Work items 1–3 with the domain owner. This costs days and saves the quarter a premature build would spend.

When this changes

Regulated or safety-relevant decisions

Medical, biometric, and safety-critical applications need more than this checklist — regulatory review, bias analysis, and domain-specific validation. They are outside its scope by design.

Open-ended understanding

If the feature is "understand any image a user sends", items 1 and 3 cannot be answered — which is the checklist telling you to narrow the product scope, not to skip the checklist.

No examples exist yet

Pre-launch products can pass items 1–3 and 7–12 while item 4 is honestly "not yet". Then the next step is a collection plan, and any model work before it is decoration.

Limitations

What the checklist cannot do

  • It cannot produce a verdict. Feasibility is decided by testing on representative data — the checklist only makes that test possible and honest. The four verdicts are described on the feasibility page.
  • It cannot see your data. A confident score built on unrepresentative examples fails at item 4 without knowing it — collection quality is the item most teams over-report.
  • It does not rank solution families. That is a separate decision — see how to choose a model.

In short

Before building image recognition, pass twelve checks: a one-sentence decision, priced failure directions, expert agreement, 100+ representative images with recorded answers, bounded variability, per-direction accuracy bars, a latency budget, 12-month volume economics, a privacy ruling, an abstention path, and a named owner for correctness over time. Ten or more — evaluate now; seven to nine — collect what is missing; six or fewer — the problem is definition, not modeling.

Related: feasibility testing explained · how many images you need