
PoC vs Prototype vs MVP: Which One to Build First, and What Each Costs
A PoC proves feasibility, a prototype proves usability, an MVP proves demand. How to tell which question is still open, and what each step costs at Empat.
A proof of concept proves that something is technically possible. A prototype proves that people can use it. A minimum viable product proves that people want it and will pay for it. They answer three different questions, they cost very different amounts, and the one you should build first depends entirely on which question is still open for your product.
This guide is for a founder or product lead deciding what to build first and how much to spend before committing to a full product. It covers what each of the three actually is, when each is the right first step, the trap of calling a prototype an MVP, a four-question decision path, and what each one costs and takes at Empat.
The one-line answer: if the open question is "can it be built", start with a PoC; if it is "will people understand it", a prototype; if it is "will people pay", go to an MVP. Skipping a step is fine when its question is already answered; skipping it because the step feels slow is how projects lose months.
What is the difference between a PoC, a prototype and an MVP?
The difference is in what each one proves and who it is for. A PoC is an internal experiment that tests one technical risk. A prototype is a visual or clickable model that tests the experience with users and stakeholders. An MVP is a real, working, shippable product with the smallest feature set that lets real users get real value, so you can measure demand.
| Proof of concept | Prototype | MVP | |
|---|---|---|---|
| Question it answers | Can this be built, and does it hold up technically? | Do users understand and want to use this? | Will real users adopt it and pay for it? |
| What you get | A working slice of the risky part, usually ugly | Clickable screens or a mock flow, usually no real backend | A real product with the smallest complete feature set |
| Who sees it | Your team, a technical advisor, sometimes an investor's CTO | Users in tests, stakeholders, investors | Real customers |
| Typical duration | 2–4 weeks | 1–3 weeks | 6–12 weeks |
| Typical cost at Empat | From $15,000 | Part of discovery, from $5,000 | From $30,000 |
| What it is not | Not a product; throw-away code is normal | Not working software; nothing behind the buttons | Not a demo; it must survive real use |
One thing the table does not show: the three are not stages you must pass through in order. They are tools, and you pick the one whose question is open. Many products need only an MVP; some need a PoC and then an MVP with no prototype in between; a few need all three.
When do you need a proof of concept?
You need a PoC when a single technical uncertainty could sink the project: an integration that may not expose what you need, an AI feature whose accuracy on your data is unknown, a performance requirement nobody has hit before, or a data source that may not be usable. The PoC tests exactly that risk, on real data, and nothing else.
Two examples from the kinds of work we do most often. First, an AI feature: a product wants to classify or extract something from customer documents, and nobody knows whether a model can do it accurately enough on those specific documents. A PoC runs the model on a few hundred real examples and measures accuracy against what humans decided. If it clears the bar, the MVP is a safe bet; if it does not, you learned that for a fraction of the build cost. Almost every AI feature deserves this step, which is why our AI MVP engagements begin with one.
Second, an integration: the product depends on pulling records out of a system you do not control — an EHR, a payment provider, a legacy ERP. The PoC connects to it and moves one real record end to end. The engineering is usually small; what you learn about access programs, fees and data quality is what changes the plan. See our guide to AI integration services for how this plays out when the integration and the AI risk are the same feature.
When do you need a prototype?
You need a prototype when the risk is in the experience rather than the technology: users may not understand the flow, stakeholders cannot agree on what the product is, or you need something to show investors before any code exists. A clickable prototype answers those questions in days, and it is the cheapest way to find out you were building the wrong thing.
Fidelity is a choice, not a given. Nielsen Norman Group separates low-fidelity prototypes, which are fast to change and good for testing a flow, from high-fidelity ones that look and behave close to the real product. Start low, and raise fidelity only once the flow holds up with users.
The caution is the reverse of its strength. Because a good prototype looks finished, people start treating it as one. There is nothing behind the buttons: no data, no logic, no edge cases, no performance. A prototype tells you whether the idea is understood; it tells you nothing about whether it can be built or whether anyone will pay. Our product validation work is where prototypes earn their keep — testing the idea with the target audience before the build.
When do you go straight to an MVP?
Go straight to an MVP when the technical path is known, the core flow is clear, and the real question is demand. Most products built on familiar stacks with familiar patterns are in this position: there is no technical unknown worth a PoC, and a prototype would only delay the answer that matters, which comes from real users with real money. That is what the term meant in Eric Ries's Lean Startup method: the smallest product that starts the build-measure-learn loop with real customers.
The trap is calling a prototype an MVP. An MVP is minimal, but it is viable: it works, it handles real data, it survives real users, it can be supported. A beautiful shell that breaks on the first real account is not an MVP, and launching it burns the users you most needed to keep. The test is simple — could a paying customer use this for a week without someone from your team standing behind it? If not, it is still a prototype.
The cost of skipping the cheap test is well documented for AI products: Gartner expects more than 40% of agentic AI projects to be canceled by the end of 2027, mostly over escalating costs and unclear business value. The point of choosing the right first step is to make the bet small before it gets big.
How do you decide which one to build first?
Answer four questions in order. Each "yes" points at a step; the first "yes" you hit is where you start. If none is a yes, you are ready for an MVP.
- Is there one technical thing that, if it does not work, kills the product? An integration, an AI accuracy threshold, a performance target, a data source. Yes → PoC first.
- Do users or stakeholders disagree about what the product is, or has nobody outside the team seen the flow? Yes → prototype first.
- Do you need something to show investors before you can fund the build? Yes → prototype, and possibly a PoC for the technical story.
- Is the only open question whether people will adopt and pay? Yes → MVP now, with the smallest feature set that delivers the core value.
A common combination for AI products is questions 1 and 4 both being yes: a PoC to confirm the model works on your data, then straight to an MVP without a separate prototype, because the interface is simple and the risk was never the UX.
What does each one cost and take at Empat?
Empat's engagements map directly onto the three: discovery from $5,000 over one to two weeks, which is where prototypes usually live; a proof of concept from $15,000 over two to four weeks; an MVP from $30,000 over six to twelve weeks; and a full product from $50,000 over three to twelve months or more.
- Discovery — from $5,000, 1–2 weeks. Scope, risks, a prototype where the experience is the question, and a written recommendation on which step comes next. Sometimes the recommendation is "you don't need a PoC; go to the MVP."
- Proof of concept — from $15,000, 2–4 weeks. The risky component, working on your real data, with a measured result and a go or no-go decision.
- MVP — from $30,000, 6–12 weeks. A real product with the smallest complete feature set, in front of real users.
- Full product — from $50,000, 3–12+ months. Built on what the MVP proved, with the roadmap driven by usage.
Two honest notes. PoC code is usually thrown away, and that is the point — do not pay to make it production-grade. And an MVP that is not viable is more expensive than one that is, because you pay for it twice: once to build and once to rebuild. If you want a first-pass number for your own idea, our project cost calculator is a starting point, and our MVP development page describes how the MVP stage runs.
If the open question is who should build it rather than what to build first, our guides to choosing a custom software development company and to software development consulting cover that next decision.
FAQ
What is the difference between a proof of concept and a prototype?
A proof of concept tests whether something is technically possible — an integration, an AI feature's accuracy, a performance target — and is usually an ugly working slice seen only by your team. A prototype tests whether people understand and want the experience: clickable screens with nothing behind them, shown to users and stakeholders. One tests feasibility, the other tests usability.
Should I build a PoC or an MVP first?
Build a PoC first only if a single technical uncertainty could sink the product — an integration that may not work, an AI feature whose accuracy on your data is unknown, a performance requirement nobody has hit. If the technical path is known and the real question is whether people will adopt and pay, go straight to an MVP. A PoC that tests no real risk is just a delay.
How much does a proof of concept cost?
At Empat, a proof of concept starts from $15,000 and takes two to four weeks. It covers the risky component working on your real data, a measured result, and a go or no-go recommendation. The code is usually thrown away afterwards, which is expected; the value is the answer, not the artefact. Discovery, from $5,000, comes first and often decides whether a PoC is needed at all.
Can a prototype become the MVP?
The design can; the code usually should not. A prototype's screens and flows are the natural starting point for the MVP's interface, but a prototype has no real backend, data handling or edge cases, and building production logic underneath a throwaway shell tends to cost more than starting the MVP cleanly with the prototype as its specification.



