Direct answer: Build a feasibility prototype before an MVP when one technical, data, integration or workflow assumption could invalidate the product plan. The prototype should answer that narrow question with evidence; it is not an unfinished MVP or a shortcut into production.
An MVP tests whether a usable product creates customer value. A feasibility prototype tests whether a critical approach can work within defined constraints. Combining them can hide technical failure inside a poor user experience or vice versa.
Start with the product outcome
State the decision the prototype must support: can the model meet an accuracy threshold, can the partner API complete the required workflow, can the device process data within latency or battery limits, or can legacy data be migrated safely?
- A single falsifiable feasibility question.
- Representative data, devices, integrations and constraints.
- Acceptance thresholds set before implementation.
- Instrumentation that records latency, quality, cost and failure.
- A short technical decision record with alternatives.
- A deliberate plan to discard, harden or replace the prototype.
A feature earns its place when it supports the core journey, removes an operational failure or creates evidence for the next decision. Everything else can wait for a measured iteration.
Architecture and data flow
Isolate the uncertain component behind a simple harness. Avoid building account systems, polished navigation and broad infrastructure unless they are part of the feasibility question.
Use representative conditions rather than a perfect demonstration environment. Include realistic data volume, network behavior, device class, rate limits and failure responses.
Record what is intentionally unsafe or temporary. Prototype credentials, copied data and permissive configuration must not drift into an MVP repository or production environment.
Security and privacy belong in the architecture, not in a final checklist. Define roles, least-privilege access, retention, consent, audit events, incident response and deletion behavior before integrations multiply.
Decisions to make before development
- Name the assumption that could change the roadmap.
- Set pass, fail and inconclusive thresholds.
- Choose representative inputs and edge cases.
- Limit time and cost so the experiment stays focused.
- Decide who reviews the result and what each outcome triggers.
These decisions turn a broad idea into an estimable product. They also expose dependencies that can change scope, such as partner APIs, app-store rules, regulated data, hardware, content operations or third-party commercial terms.
A focused first release
After feasibility is demonstrated, redesign the chosen approach for a complete user journey, security, maintainability and operations.
- Translate evidence into architecture requirements.
- Rebuild temporary code where production quality requires it.
- Add identity, permissions, observability and support.
- Test customer value independently of technical success.
- Preserve the prototype report as a decision record.
Instrument the release around completion, failure and repeat value. Product analytics should answer whether users complete the core task, where they abandon it and which operational exceptions consume the team’s time.
Common mistakes and how to avoid them
- Calling a polished clickable mockup a technical feasibility test.
- Changing acceptance criteria after seeing weak results.
- Using clean sample data that excludes real exceptions.
- Shipping prototype code because it worked once.
OpenGeeksLab can help with product discovery and MVP planning, custom software development and product and UI/UX design. The engagement starts with the product decision, then connects experience, architecture and delivery to a measurable business result.
Authoritative implementation references
- Microsoft architecture design specification guidance — Requirements, alternatives, security, testing and rollout decisions.
- GOV.UK discovery guidance — Reducing uncertainty before committing to delivery.
Frequently asked questions
How long should a feasibility prototype take?
Long enough to test the riskiest assumption under representative constraints, usually with a strict time box and pre-agreed evidence threshold.
Should prototype code be reused?
Only after review. Experimental code often omits security, error handling, maintainability and operational controls that an MVP needs.
What if the result is inconclusive?
Record what remains unknown, improve the experiment only if the decision value justifies it, or choose a lower-risk alternative.


