Prototype, MVP or production app: what do you need first?
A prototype, an MVP and a production app answer three different questions. Building the wrong one first is the most expensive way to learn which you needed.
· By Tural Jumshud · 8 min read
A prototype is a model of your product built to test an idea with a handful of people, and it's meant to be thrown away. An MVP (minimum viable product) is a real, working product with the fewest features that lets real customers show you whether they want it. A production app is built to be relied on: secure, backed up, maintained and ready to grow.
All three get called "the first version", which is where the trouble starts. Each answers a different question, takes a different amount of time, and fails in a different way when it's used for the wrong job.
We design products and then build them, so we see founders arrive at every one of these stages, often with the wrong one in hand. Here's how we tell them apart, and how to decide which you need next.
What is a prototype?
A prototype is a question you can hold. Nielsen Norman Group describes a user interface prototype as a hypothesis: a candidate design for a specific problem, which you test by watching people use it.
It can be sketches on paper, a clickable Figma file, or, increasingly, a working front end made in an AI builder. What it has in common: no real users, no real data, and no promise that anything survives. NN/g puts the economics plainly: ripping up code is very expensive, ripping up a prototype is not, especially if it's a piece of paper.
- What it proves: that people understand the idea, can find their way through the main task, and want what's on the screen.
- Who uses it: you, your team and five to ten people you watch closely.
- How long it takes: in our experience, days to a couple of weeks.
- What happens after: you change the design, test again, then build from what you learned, not from the prototype's code.
What is an MVP?
An MVP is a real product put in front of real customers to learn whether they'll use it, return to it or pay for it. Eric Ries, who popularised the term in The Lean Startup, defined it as the version of a new product that lets a team collect the most validated learning about customers with the least effort.
The key word is learning. An MVP isn't just the smallest thing you can ship, and it doesn't have to be an app. Dropbox's MVP was a three-minute demo video, narrated by founder Drew Houston, showing how the product was meant to work. Houston said the beta waiting list went from 5,000 to 75,000 people overnight. That answered the question that mattered (do people want this?) before the hard engineering was paid for.
The Agile Alliance lists the ways teams get MVPs wrong. These three are the ones we see most:
- All minimum, no viable. Cutting so much that the product can't do its one job well, so people leave and you learn nothing.
- Learning versus earning. An MVP is for learning. A minimum marketable product is for selling. Mixing them up gives you a product that does neither well.
- Ship and freeze. Launching the MVP, then not changing it whatever customers say. If nothing will change, it wasn't an experiment.
In short:
- What it proves: that real customers, not friends, will use it, come back and maybe pay.
- Who uses it: a small group of real users, often by invitation or in one market.
- How long it takes: usually weeks to a few months.
- What happens after: you change direction, double down, or stop, based on what people actually did.
What makes an app "production"?
A production app is one people rely on, and that you can keep changing without breaking. The features may look the same as the MVP's. The difference is mostly invisible: what happens when something goes wrong.
Before we call something production-ready, we want clear answers to these:
- Data: each user can only reach their own data, and secret keys never reach the browser or the phone.
- Recovery: there are automatic backups, and someone has restored one to prove it works.
- Change: there's a separate test copy, so a new feature can't damage real users' data.
- Watching: someone finds out when it breaks before customers do.
- Ownership: the code lives in an account you own, and someone is responsible for maintaining it.
- Obligations: payments, privacy, accessibility and app store rules are handled for the places you sell.
Production isn't the same as "finished". Martin Fowler notes that eBay began in 1995 as a set of Perl scripts built over a weekend, was rebuilt in C++ in 1997 and again in Java in 2002. He also cites Google's rule of thumb, from Jeff Dean: design for about ten times your current needs, and plan to rewrite before a hundred times. A production app is built for the next order of magnitude, not for ever.
How do the three compare?
The short version, side by side:
- The question it answers: prototype, "does this design make sense?"; MVP, "will real people use or pay for it?"; production, "can people rely on it as it grows?"
- Real users and data: prototype, none; MVP, a small group; production, everyone.
- Built to last: prototype, no; MVP, partly (decide which parts in advance); production, yes, for the next stage of growth.
- The usual failure: prototype, testing it only on people who like you; MVP, cutting the part that makes it useful; production, building it before anyone has proved they want it.
What's the trap of shipping a prototype as a product?
The prototype looks finished, so it goes live, and real people's data ends up in something that was never built to protect it. This trap is far more common since AI builders such as Lovable, Bolt and Figma Make started producing working prototypes in an afternoon.
That speed is a gift for prototyping. The problem is that a working AI-built app and a production app look identical from the outside. In October 2025, Escape scanned more than 5,600 public apps built on vibe coding platforms and found over 2,000 vulnerabilities, more than 400 exposed secrets and 175 cases of exposed personal data. We wrote up five checks to run in security checks for your vibe coded app.
Signs your prototype has quietly become a product:
- Strangers have signed up, not just people you invited to a test.
- It stores anything personal: emails, health details, payments, photos.
- Someone would be upset if it disappeared tomorrow.
- Changing one screen breaks another, and nobody is sure why.
If two or more are true, stop adding features and decide: harden what you have, or use it as the brief for a proper build.
Which one do you need first?
Start with the biggest thing you don't know yet, and build the cheapest thing that answers it. These four questions, in order, usually settle it.
Is the technology itself the risk?
If you don't know whether something can be done at all (a model accurate enough, a sensor fast enough), test that first with a proof of concept. It rarely needs any design, and most products can skip it.
Do you know how it should work for people?
If you can't yet describe the main task step by step, or haven't watched anyone try it, build a prototype. Test with five to ten people from your audience, change it, and test again.
Do you know people want it enough?
If the design works in tests but you don't know whether people will sign up, return or pay, build an MVP. Pick one measure of success before launch, such as weekly active users or paid conversions, so the result means something.
Are people already relying on it?
If customers are paying, storing personal data or using it for work, you need production quality now, whatever you called the last version. Make it safe before you make it bigger.
Can an MVP grow into the production app?
Yes, if you plan for it. We decide before building which parts of an MVP are meant to last and which are allowed to be thrown away. The parts that hold data, money and logins get built properly from day one, because they're the hardest to replace later. Screens, copy and features get built quickly, because they'll change anyway.
Fowler's term for the deliberate version is sacrificial architecture: accepting now that you'll replace some of what you're building, and making it easy to replace when the time comes. That's not wasted work. The weekend Perl scripts are part of why eBay got to the point where it needed Java.
How did this work on Final Table?
Final Table, our poker hand-logging app, followed this order. The core question was design, not technology: could a player log a hand in a few seconds, one-handed, without losing track of the table? So the gesture pad (tap to check, swipe to fold, drag to raise) was tested with more than 100 players before launch. The one change they asked for was showing the table above the pad, so they didn't have to keep the game in their heads.
The first build spaced the bet sizes on the pad evenly. Testing showed that some sizes are used constantly and some rarely, so we widened the common ones and tightened the risky one, all-in. That's the kind of detail you only find by watching real thumbs at a real table, and it's far cheaper to find before launch than after.
The app first shipped into two poker clubs, which did the job of an MVP: real players, real sessions, a small group. Its onboarding asks five questions (what you play, why, how often, your experience, what you want to find out), because download numbers don't tell you who your users are. The answers don't change the interface; they shape what gets built next. Final Table is now live on the App Store and Google Play.
That's how we approach product design in general: work out which question comes first, answer it with the cheapest thing that will do, and only then build for keeps.
FAQs
What is the difference between a prototype and an MVP?
A prototype is a model you show a few people to test whether a design works; it usually isn't real software and is meant to be thrown away. An MVP is a real product with the fewest features needed to learn whether real customers will use or pay for it.
Is a proof of concept the same as a prototype?
No. A proof of concept checks whether something is technically possible, often with no interface at all. A prototype checks whether people understand and want the design. You only need a proof of concept when the technology itself is the risk.
Can I launch my prototype as an MVP?
Only if it can safely hold real people's data. AI builders now make prototypes that look finished, but they often lack access rules, protected keys and backups. Fix those first, or treat the prototype as the brief for a proper build.
How long does it take to build an MVP?
It depends on the product, but in our experience a focused MVP takes weeks to a few months, not days. If it's taking longer, the 'minimum' has usually grown. A prototype to test the idea first can take days.
Does an MVP have to be an app?
No. An MVP is whatever lets you learn from real customers with the least effort. Dropbox's was a three-minute demo video of how the product would work, which took its beta waiting list from 5,000 to 75,000 people overnight.
Sources
- Nielsen Norman Group, UX Prototypes: Low Fidelity vs. High Fidelity, Kara Pernice, December 2016, via NN/g
- Agile Alliance, Minimum Viable Product (MVP) glossary entry, updated October 2023, via Agile Alliance
- Eric Ries, How Dropbox started as a minimal viable product, excerpt from The Lean Startup, October 2011, via TechCrunch
- Martin Fowler, Sacrificial Architecture, October 2014, via martinfowler.com
- Escape, analysis of 5,600+ apps built on vibe coding platforms, October 2025, via Escape
Work with me

Let's talk about your project.
Not sure whether you need a prototype, an MVP or a proper build? We design products and then build them, so we can help you pick the smallest step that answers your real question, and plan the next one. Let's talk.