# Prototype vs proof of concept vs MVP vs pilot: what to build first

URL: https://pixelactstudio.com/blog/prototype-vs-pilot-vs-mvp

> Prototype vs proof of concept vs MVP, and where a pilot fits: definitions, a comparison table, a worked decision flow for your first build, and common mistakes.

By Dev Talan. Published 2026-11-01. Updated 2026-11-01. Type: Guide.

## Key takeaways

- Build a prototype when the flow is in doubt, a proof of concept when the technology is, and a pilot of one workflow on live inputs when the operational value is. Build the MVP when only demand is left untested.
- When the flow and the technology are both in doubt, start with the proof of concept, because a flow users love is worth little if the core cannot run at a cost the price can carry.
- A tool that replaces a spreadsheet an ops team already uses, on Postgres and a standard web stack, has no open question for a prototype to answer and can go straight to a tightly scoped MVP.
- A prototype has become an MVP once someone outside the team signs in, it stores customer data, or money moves through it. From then on, sign-in, data integrity, payments, and monitoring must be production-grade.
- Write pass criteria that can fail, such as no unflagged errors in PO numbers or totals across 300 real invoices, and agree before work starts which result means build, change direction, or stop.

A prototype, a proof of concept, and an MVP each prove a different thing. A prototype tests whether users understand and want a flow. A proof of concept tests whether the hardest technical part can work. An MVP tests whether real users rely on the product and pay. A pilot runs one working piece under real conditions.

Which one comes first depends on the assumption that would end your plan if it were wrong. This guide to prototype vs proof of concept vs MVP is for founders and product leads at seed and Series A startups choosing where to spend their first real software budget. It defines each term, compares them side by side, gives a decision flow, and lists the mistakes that waste a first build.

The terms are used loosely. One studio's prototype is a Figma file, and another's is half an app. Whatever you call the first build, agree in writing what it will prove and which parts are real.

## What are a prototype, a proof of concept, a pilot, and an MVP?

Each answers one question for one audience, so each definition starts with what the build proves.

- **Prototype:** A simulation of the product that tests whether users understand a flow and want it. It ranges from paper sketches to a clickable Figma file or a thin coded front end on sample data. Nothing behind it is real: no stored customer data and no business logic anyone depends on.
- **Proof of concept:** A small piece of working code that tests whether the hardest technical part can work at the speed, accuracy, or cost the product needs. It runs on real or representative data, for example an integration with an untested API, a sync job at production volume, or a model scored against your own documents. It usually has little or no interface.
- **Pilot:** One working piece run under real conditions at a bounded scope: one team, one workflow, live inputs, a fixed period, and pass criteria agreed before it starts. It tests whether the thing holds up inside a real organization's working day.
- **Minimum viable product (MVP):** The first release that real users rely on to finish a real job with their own data, built to keep running and grow. It tests demand and behavior: whether users come back, and whether they pay.

Eric Ries defined the MVP in terms of learning rather than features in his 2009 post [Minimum Viable Product: a guide](https://www.startuplessonslearned.com/2009/08/minimum-viable-product-guide.html).

> The minimum viable product is that version of a new product which allows a team to collect the maximum amount of validated learning about customers with the least effort.
>
> Eric Ries, Minimum Viable Product: a guide, 2009

The word that gets lost in practice is viable. An MVP holds real customer data and real money, so sign-in, data integrity, payments, and monitoring have to be production-grade even when the feature list is short. Our guide on [how to scope an MVP](https://pixelactstudio.com/blog/how-to-scope-an-mvp) shows where that line sits.

## Prototype vs proof of concept vs MVP: how do they compare?

The four builds differ most in what they prove. Audience, fidelity, and output follow from that.

**Prototype, proof of concept, pilot, and MVP compared**

| Compared on | Prototype | Proof of concept | Pilot | MVP |
| --- | --- | --- | --- | --- |
| Purpose | Test whether users understand and want a flow | Test whether the hardest technical part can work | Test whether one working piece holds up in real operations | Test whether real users rely on the product and pay for it |
| Audience | Target users, the founding team, sometimes investors | The engineering team, sometimes technical advisors or investors | One team in a real organization, often a design partner | Early customers in the market |
| Fidelity | Sketches to high-fidelity clickable screens. The data is fake | Working code for one hard part, with little or no interface | Working software on live inputs, narrow in scope | Few features, but production-grade sign-in, data, payments, and monitoring |
| What it proves | Users follow the flow and say they want it. Whether they will use it or pay stays open | The hard part meets a stated speed, accuracy, or cost on real or representative data | The workflow saves the time or errors expected, and the team keeps using it for the agreed period | Users return to finish the job without being prompted, and some of them pay |
| Typical output | A Figma prototype or thin front end, plus notes from user sessions | Code in your repository, results against pass criteria, and a feasibility call | One workflow on real inputs, results, and a build, change, or stop decision | A live product with real accounts, usage data, and a backlog shaped by that usage |
| What happens next | It becomes the brief for production screens. Any code is usually rewritten | The parts that proved out can carry forward after review. The rest is rewritten | It becomes the first module of the build, or the case for not building | It keeps running and grows into the full product |

Start with the row for what each build proves. If the answer you need sits in the prototype column, an MVP would reach it later and at a much higher cost. If it sits in the MVP column, no prototype can answer it, because what users say in a test session is weaker evidence than what they do with their own work.

## What is the difference between a prototype and an MVP?

A prototype simulates the product, and an MVP is the product. A prototype can show that users follow a flow and like it. Only an MVP can show that they use it for real work, week after week, and pay for it.

AI coding tools and no-code builders blur that line, because a working prototype now takes days and looks like a finished product. Building one that way is a sensible way to learn fast. What separates the two is what the build holds, whatever it looks like. A prototype has become an MVP, whatever anyone calls it, once any of these is true:

- It stores customer data that would hurt to lose or leak.
- Someone outside the team signs in with their own account.
- Money moves through it, or a customer pays for access.
- A user's daily work depends on it staying up.
- A second customer's records sit in the same database as the first customer's.

From that point, gaps a prototype could live with become risks: no tenant isolation, [API keys exposed in the client bundle](https://pixelactstudio.com/blog/exposed-api-keys), no tested backups, and no automated tests on sign-in or billing. The [AI-built app risk checklist](https://pixelactstudio.com/resources/ai-built-app-risk-checklist) walks through what to check before more customers arrive.

## What is the difference between a pilot and an MVP?

A pilot is bounded and ends with a decision, while an MVP is open-ended and built to keep running. A pilot tests one working piece inside one organization for a fixed period. An MVP is the first version of a product you intend to sell to many customers.

In B2B software the word pilot carries two meanings, and both share that bounded shape.

- **A customer pilot.** A startup deploys its product, or one part of it, at one customer for an agreed period, with success criteria both sides have signed off. It usually runs on an early MVP and decides whether that customer buys.
- **A pilot build.** A short, fixed-price project that proves one thing before a bigger commitment. At Pixelact, a [pilot sprint](https://pixelactstudio.com/services/pilot-sprints) produces a clickable prototype, a technical proof of concept, or one automated workflow on live inputs, and ends with a written recommendation to build, change direction, or stop.

So a customer pilot usually comes after an early MVP exists, and a pilot build usually comes before it. In both cases, check for an end date. A pilot with no end date and no pass criteria has turned into a free trial, and a free trial seldom forces anyone to decide.

## What comes first, a prototype or an MVP?

A prototype or a proof of concept usually comes before an MVP, but only when it answers a question that is still open. The order follows risk.

A fixed path from proof of concept to prototype to MVP fits a product with both an untested technical core and an untested flow. Plenty of products have neither. A tool that [replaces a spreadsheet an ops team already uses](https://pixelactstudio.com/blog/replace-spreadsheets-with-internal-tools), built on Postgres and a standard web stack, has no feasibility question and a known workflow, so it can go straight to a tightly scoped MVP.

- **Flow in doubt, technology ordinary:** build a prototype first.
- **Technology in doubt, flow obvious:** build a proof of concept first.
- **Both in doubt:** start with the proof of concept, because a flow users love is worth little if the core cannot run at a cost the price can carry.
- **Operational value in doubt:** pilot one workflow on live inputs.
- **Flow, technology, and operations known, demand untested:** build the MVP.
- **AI feature, accuracy on your data unknown:** a proof of concept scored against an eval set comes first, which is why every [AI system](https://pixelactstudio.com/services/ai-systems) we build starts with a pilot.

## How do you decide which to build first?

Start with the riskiest assumption that a build much smaller than the product can test now. The steps below follow one example: a product that matches supplier invoices to purchase orders for accounts payable teams.

1. **Name the decision.** Write down what the result will decide and who decides it. In the example, the CEO decides whether to fund the invoice-matching MVP next quarter.
2. **List the assumptions.** Write each belief the plan rests on as one sentence: clerks will trust a suggested match, invoices can be read accurately, one team will run its weekly payments through the tool, and teams like it will pay.
3. **Rank them by risk.** Pick the assumption most likely to be wrong and most expensive to discover halfway through a build. Here it is reading the invoices, because they arrive in dozens of layouts and some are scans.
4. **Match the build to the assumption.** Apply the rules from the previous section. Reading invoices is a feasibility question, so the first build here is a proof of concept. The table below maps the other assumptions.
5. **Write the pass criteria first.** Turn the question into a result you can count, and agree it before any work starts. “The extraction works well” cannot fail, so it is not a criterion. “No unflagged errors in PO numbers or totals across 300 real invoices” can.
6. **Agree what each result means.** Decide in advance which result means build, which means change direction, and which means stop, so the readout ends in a decision.

**Matching each assumption in the invoice-matching plan to a first build**

| Assumption | Why it might be wrong | First build that tests it |
| --- | --- | --- |
| Clerks will trust a suggested match and approve invoices in batches | Nobody has watched a clerk use the flow on realistic data | Prototype: clickable approval screens on realistic invoices, tested with five or six clerks |
| Invoice PDFs can be read accurately enough to match against purchase orders | Invoices arrive in many layouts, and some are scans | Proof of concept: extraction on a few hundred real invoices, scored against an eval set |
| One team will run its weekly payment run through the tool | The team's process has exceptions nobody has written down | Pilot: one workflow on live invoices for four weekly payment runs |
| Accounts payable teams will use it every week and pay for it | Only real use can show it, once the rows above are settled | MVP: a tightly scoped first release for a small group of paying teams |

Write the outcome of those six steps as a one-page brief and keep it in the repository next to the code. A plain file is enough.

```yaml
question: Can we extract supplier, invoice number, PO number, totals, and tax from real invoice PDFs accurately enough to match them to purchase orders?
build_type: proof of concept
decision: Whether to fund the invoice-matching MVP next quarter
decision_owner: CEO
inputs:
  - 300 redacted invoices from 40 suppliers, including scans
pass_criteria:
  - Every required field is extracted or flagged as uncertain on every invoice
  - No more than 1 field in 10 is flagged for human review
  - A reviewer finds no unflagged errors in PO numbers or totals
  - Cost per invoice at expected monthly volume stays within the unit cost the pricing allows
decision_rule:
  pass: Scope the MVP around automatic matching
  partial: Scope the MVP with human review on flagged fields
  fail: Stop, or test a different input such as supplier e-invoicing
ends: After the scored run, with a written readout
```

## What are the most common mistakes when choosing a first build?

Most wasted first builds answer the wrong question, or no question at all. These patterns show up often in early product plans.

- **Building an MVP to answer a prototype's question.** If the doubt is whether users understand the flow, a clickable prototype tested with a handful of users answers it months sooner.
- **Testing a proof of concept on clean data.** Vendor demo files are tidier than the scans customers send. Include the messy inputs, or the proof shows less than it seems to.
- **Asking one build two questions.** If a pilot tests both the extraction and the approval flow and fails, you cannot tell which part failed. Give each question its own pass criteria, or its own build.
- **Leaving the budget holder out of a customer pilot.** Users can love a pilot that never becomes a purchase, because the person who signs the contract never agreed what success meant. Have that person sign off the pass criteria before the pilot starts.
- **Fitting the product to the pilot customer.** One organization's exceptions become features every later customer carries. Mark customer-specific requests before they reach the roadmap.
- **Putting a prototype in front of paying customers unchanged.** A prototype rightly skipped hardened sign-in, tenant isolation, backups, and tests, because it did not need them. Paying customers do. Decide what to keep before scaling it, and our guide on [whether to rebuild or refactor](https://pixelactstudio.com/blog/rescue-or-rebuild) covers how to make that call.

> **A prototype that impresses is not evidence of demand.** Polished screens draw good reactions from investors and users, but praise in a test session costs the person giving it nothing. Stronger signals cost them something: a signed letter of intent, a paid customer pilot, or a team moving real work into the product. Treat prototype feedback as evidence about the flow, not about demand.

## What should you do next?

Write down the decision your first build should feed and the one assumption you are least sure of, then pick the build from the comparison table that tests it. If you cannot name that assumption yet, the plan needs scoping before it needs building, and the [MVP readiness checklist](https://pixelactstudio.com/resources/mvp-readiness-checklist) helps narrow it down.

If one risk stands between you and the build, a [pilot sprint](https://pixelactstudio.com/services/pilot-sprints) tests it at a fixed price from $4,500 against pass criteria agreed upfront.

## Frequently asked questions

### How high fidelity should a prototype be?

Match fidelity to the question. Wireframes or paper sketches are enough to test structure and navigation. To test whether clerks will trust a suggested invoice match, as in the example above, use high-fidelity approval screens with realistic invoices, because placeholder data hides the problems that matter there. Stop polishing once the screens can answer the question.

### What is a proof of value, and how is it different from a proof of concept?

A proof of value shows that a product delivers a measurable business result in a buyer's own environment, such as hours saved each week on a named process. A proof of concept only shows that something can technically work. Enterprise buyers often ask for a proof of value during procurement, and in practice it runs like a customer pilot with agreed success metrics.

### Should a customer pilot be paid?

Usually, even at a modest price. Payment brings a budget holder into the decision, makes both sides write the success criteria down, and gives the pilot a natural end date. An unpaid pilot can still make sense with a design partner whose feedback shapes the product, as long as the criteria, the end date, and the decision that follows are agreed in writing.

### Can an MVP be partly manual?

Yes. In a Wizard of Oz MVP, users work through a normal interface while the team does some steps by hand behind it. In a concierge MVP, the team delivers the service by hand, openly. Both test demand before the automation exists. It is still an MVP if real users rely on it for real work, so whatever does run in software, such as sign-in and stored data, has to be built properly.

### How long should a prototype, proof of concept, or pilot take?

As short as the question allows, with the end date fixed before work starts. In the invoice-matching example, the proof of concept ends after one scored run on 300 invoices, and the pilot ends after four weekly payment runs. A proof of concept that waits on sandbox access or real data from a third party usually takes longer than a clickable prototype on sample data. If any of them keeps growing, it is usually trying to answer more than one question and should be split.

### Should a proof of concept use the production stack?

For the part being proved, yes, whenever the result depends on it. Latency, cost, and rate limits measured in a notebook or a different language can change once the code runs in the real service, against the real database, on the API tier you will actually pay for. Code outside the proved part can stay rough, because it will be rewritten.