The “Minimum Viable Prototype”: How Much Fidelity is Really Needed to Answer Your Question?

In design, we are often taught that prototypes progress in a linear fashion: sketch, wireframe, high-fidelity mockup, interactive prototype, coded MVP. This is a process of fidelity, but not necessarily a process of learning. The result is teams spending weeks polishing a Figma prototype to test a basic user flow, or engineers building a fully functional product to answer a question a simple conversation could have resolved.

The real skill is not in building prototypes. It is in building the least amount of prototype necessary to learn the most important thing. This is the Minimum Viable Prototype (MVPt): the simplest, fastest artifact that reliably tests your specific hypothesis.

The Decision Framework: Match Fidelity to Your Question

Stop asking, “What tool should we use?” Start asking, “What do we need to learn?” Your prototype is an experiment. Define the hypothesis first.

1. Hypothesis: “Is this concept fundamentally valuable or understandable?”

You are testing: The core idea, metaphor, or value proposition.

• Minimum Viable Prototype: A storyboard or a value proposition sketch.
• Tool: Paper, whiteboard, a simple digital sketch.
• Why it works: You need narrative and reaction, not interaction. Show a sequence of 3-4 panels depicting the user’s problem and how your concept solves it. Present it and ask, “Does this seem like it would solve a real problem for you?”
• Example: Testing a new “family calendar” concept. Don’t design screens. Draw a mom seeing a notification that soccer practice is moved, easily swapping times with another parent, and the calendar updating for the whole family. The test is the “aha!” moment, not the button style.

2. Hypothesis: “Does this information architecture or workflow make logical sense?”

You are testing: Structure, hierarchy, and navigation logic.

• Minimum Viable Prototype: A low-fidelity wireframe or a clickable wireflow.
• Tool: Figma/FigJam in wireframe mode, Balsamiq, or even paper with an overlay linking tool like Marvel.
• Why it works: You need to test categorization and flow without the distraction of visual design. Use gray boxes, lorem ipsum, and simple links. The user’s ability to find a key piece of information or complete a multi-step task is the metric.
• Example: Testing a new dashboard layout. Create wireframes with boxes labeled “Monthly Revenue Chart,” “Recent Activity List,” “Quick Stats.” Ask the user to “find where you’d see which clients were overdue on payments.” If they click the right box, your IA works.

3. Hypothesis: “Do users understand what this UI element is and what it does?”

You are testing: Clarity of affordances, labels, and visual hierarchy.

• Minimum Viable Prototype: A high-fidelity, static mockup of a single state or a critical screen.
• Tool: Figma, Sketch, Adobe XD.
• Why it works: You need realistic visuals to test immediate comprehension. Present a single screen or a comparison of two variants (A/B). Ask the 5-second test question: “What can you do on this screen? What is the most important element?”
• Example: Testing a new pricing table. Design it with final typography, colors, and styling. Ask, “Which plan seems best for a small team of 5?” If they hesitate or misinterpret the features, your visual communication has failed.

4. Hypothesis: “Can users successfully complete this specific, interactive task?”

You are testing: The usability of a specific interaction sequence.

• Minimum Viable Prototype: A high-fidelity, interactive prototype of a single, focused flow.
• Tool: Interactive features in Figma, Protopie, Framer.
• Why it works: You need to simulate the feel of the interaction. The prototype should only include the “happy path” and major error states for that one flow. The click target, feedback, and transition are what you’re evaluating.
• Example: Testing a new checkout flow. Build a prototype that goes from cart to order confirmation. Can they enter promo codes, select shipping, and understand the progress steps? The interactivity is non negotiable here.

5. Hypothesis: “Does this feel right? Does it work in real conditions?”

You are testing: The holistic experience, technical feasibility, and performance.

• Minimum Viable Prototype: A coded prototype in the target environment.
• Tool: HTML/CSS/JS, React/Vue prototype, a no-code tool like Webflow.
• Why it works: For testing complex animations, real form validation, actual API calls, or true mobile device behavior, only code gives you the real fidelity. The “feel” of a native swipe gesture or the load time of an image grid is impossible to fake perfectly.
• Example: Testing a new drag and drop interface or a real time collaborative feature. You need to test the latency, the tactile feedback, and the edge cases that Figma cannot simulate.

The Anti Pattern: The “Just in Case” Prototype

The most common waste is building a high fidelity, interactive prototype when your question is about concept value. You spend days connecting every screen, polishing micro interactions, only to learn in the first 30 seconds of testing that users don’t even want the feature. You tested interaction fidelity when you needed to test concept validity.

The MVPt Mantra: Start with the Question, Not the Tool

At your next kickoff, use this script:

1. “What is the single biggest unknown we have about this design?”
2. “Let’s phrase it as a testable hypothesis: ‘We believe that [doing X] will result in [user outcome Y].'”
3. “What is the simplest artifact we can create to prove or disprove that?”

This disciplined approach conserves your most precious resources: time and attention. It ensures every hour spent prototyping is an hour spent learning, not just making. It frees you from the tyranny of high fidelity for its own sake and makes you a strategic scientist of the user experience.

Build just enough to learn. Then decide what to build next.