My Working Definition of an MVP: Learning Instead of Shipping Half-Finished
I use MVP for an experiment that honestly tests a risky assumption. This working definition keeps a merely reduced feature set from counting as learning.
If you leave out half and call the result an MVP, you haven’t reduced any risk; you have only postponed the day the mistake becomes obvious. The build time is spent, something half-done has shipped, and the most expensive question is still in the room, unchanged: How do we know we are building the right thing at all?
Still, the word is attached in exactly this sense to roadmaps, ticket titles and budget lines. Fewer buttons, fewer screens, less backend – MVP has become a polite expression for “the product, but worse”. The reduced feature set doesn’t answer a single open question. It confuses speed in building with speed in learning.
For my work, I stick to the reading from Lean Startup: an MVP is an experiment, the smallest version of a product with which a concrete, risky assumption can be tested honestly. The term is used differently in practice, too; this working definition is my deliberate choice. From it follows what belongs in, what doesn’t, and why the apparent detour via learning can be the fastest way to a viable product.
The definition that carries everything#
In 2011, Eric Ries put the term like this in “The Lean Startup”: an MVP 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.” The core is in two words: validated learning. The purpose is learning confirmed by real data, namely about the leap-of-faith assumptions – the assumptions the whole idea rests on and that nobody has backed up so far.
That makes the MVP not a delivery step but the build part of an experiment. Ries places it in the Build-Measure-Learn loop: we build something, measure the reaction, learn from it and decide. The outcome of an MVP is always a decision, which Ries calls pivot or persevere – stay the course, or discard the assumption and turn.
flowchart LR
A[Risky assumption] --> B[Build:<br/>MVP as an experiment]
B --> C[Measure:<br/>real users, real metric]
C --> D[Learn:<br/>validated learning]
D --> E{pivot or<br/>persevere?}
E -->|persevere| A
E -->|pivot| AFor this working definition, this yields a hard criterion that is missing in everyday practice: an MVP without a defined learning question and without a metric is then not an experiment but just a small product. The difference isn’t academic. If nobody wrote down beforehand which assumption is being tested and how you recognize the outcome, the result can’t refute anything either. You build, launch, find it “pretty okay” and carry on – you have learned nothing.
Steve Blank states the other side of the misunderstanding directly: “A minimum viable product is not always a smaller/cheaper version of your final product.” His customer development approach revolves around a single imperative: get out of the building. The truth about the product isn’t in the meeting room; it is with the users. The MVP is the tool you use to go out.
A vertical slice instead of a horizontal amputation#
The difference can be shown with two cuts through the same planned scope.
The wrong MVP is a horizontal cut. You take all planned features and build each one to forty percent. The registration form is half done, the search returns results without filters, the checkout ends in a dead end. Nothing works end to end. At no point does the user get from the start to the value. There is nothing to measure, because there is no complete path anyone could go through.
The MVP is often a vertical slice: a thin but continuous path from the user to the value, with a measurement at its end. With concierge, Wizard-of-Oz or landing page experiments, though, the smallest reliable test can look different. What matters is not the shape of the cut but whether it honestly tests the risky assumption.
flowchart TB
subgraph L[Horizontal: half-finished]
L1[Feature A – 40%]
L2[Feature B – 40%]
L3[Feature C – 40%]
end
subgraph R[Vertical: smallest learning product]
R1[Entry] --> R2[one continuous path] --> R3[Value] --> R4[Metric]
endThis is exactly where the meaning of “viable” lies. The word doesn’t refer to quality; it refers to scope. Minimal is the scope, not the care. A buggy, cobbled-together MVP distorts the learning signal, because in the end you don’t know whether users reject the idea or just the broken implementation. “Viable” means: good enough to produce an honest signal. The narrow path has to be clean, otherwise you are measuring noise.
The MVP doesn’t have to be code#
The strongest evidence that “viable” doesn’t mean “fully built” are two MVP types that existed long before 2018 and get by entirely without a finished product.
In a concierge MVP, a human first provides by hand the service that software is supposed to provide later. You don’t pretend there is a product – you deliver the value directly and personally to a handful of real users and observe whether they want it at all. In a Wizard-of-Oz MVP, the user sees a real UI, but behind it there is no system but a human who enters the answers by hand. The user believes in software, the learning comes from real behavior, and almost nothing has been built.
Both test a hypothesis before a single line of production code exists. They prove the thesis in the clearest way: “viable” means enough to learn honestly, not enough to sell.
What matters here is the separation from the prototype, without turning it into an artificial wall. A prototype usually examines feasibility or usability and can of course be tested with real users for that. An MVP in my working definition, on the other hand, tests a market or value hypothesis. What counts are the question and the evidence, not whether the artifact is shown internally or externally.
The hypothesis as code#
If an MVP is an experiment, then the experiment should be declared so precisely that it can be refuted. In the projects where this held up, the hypothesis came before the first line of code – structured, versioned, next to the code in the repository instead of on a forgotten slide.
# experiment.yaml – declares the MVP before any code is written
experiment:
name: "concierge-checkout"
riskiest_assumption: "users will connect a payment method to finish an order"
hypothesis: "at least 30% of activated users will add a payment method"
target_metric: activation_rate # added payment / reached checkout
success_threshold: 0.30
kill_criteria: "activation_rate < 0.10 after 200 sessions"
sample_size: 200
cohort: "new signups, region DE"
The decisive point is the last fields. Without success_threshold and kill_criteria, it isn’t an experiment. An experiment that can’t be allowed to fail measures nothing. Agreement most often breaks down at kill_criteria, and that is exactly where its value lies: it forces the team to agree beforehand when the idea is refuted – before emotional attachment to its own solution clouds the judgment. Ries calls the opponents of these honest numbers vanity metrics: figures such as total registrations, which always point upward and never force a decision. The target_metric has to be an actionable metric that can topple an assumption.
Cutting the narrow path cleanly on the technical side#
The vertical slice also has a technical side, and here two worlds connect that are often discussed separately: product thinking and delivery.
The wrong MVP grows for weeks in a long feature branch next to the main line and at some point lands in a big, risky merge. The better way is to build the experiment on trunk and switch it on for the experiment cohort only through a feature flag. Everyone else sees the status quo; the narrow new path is fully live for a small group.
// the MVP path ships on trunk, gated by a flag – not hidden in a long branch
function renderCheckout(user, cart) {
if (featureFlags.isEnabled("concierge_checkout", user)) {
trackExperiment("concierge-checkout", user);
return conciergeCheckout(cart); // narrow but complete path to value
}
return standardCheckout(cart); // everyone else: unchanged status quo
}
That is more than a technical trick. It makes visible what an MVP is: a narrow but fully working segment – not a feature that is half visible everywhere and finished nowhere. Trunk-Based Development and short-lived branches make sure the experiment can be shipped at any time and switched off again just as quickly. Techniques such as canary release and blue-green deployment give the same principle its operational side: a small cohort gets the new thing, the rest stays safe.
If the experiment reaches beyond one service, another angle helps with honest testing. Instead of faking a full integration, the MVP service fulfills a minimal but real consumer-driven contract. The consumer writes down what it really needs, and the MVP fulfills exactly that – no more.
// consumer-driven contract: the MVP fulfils a real, minimal contract
// instead of faking a full integration
Pact.provider("payment-service").upon("checkout")
.given("an activated user")
.uponReceiving("a request to attach a payment method")
.withRequest(method: "POST", path: "/methods")
.willRespondWith(status: 201, body: [status: "attached"])
The point behind it: the narrow path is real, not a facade. It really integrates against what it needs, but only against that. That keeps the learning signal clean without having to finish building the whole system.
Why this is faster, even though it sounds like more effort#
The most common objection: setting up experiments, metrics, flags and contracts sounds like more work, not less. The objection confuses two quantities – effort per delivery and effort per insight gained.
“Accelerate” by Forsgren, Humble and Kim provides part of the technical foundation for this. The four DORA metrics of the time – deployment frequency, lead time for changes, change fail rate and time to restore – stand for delivery capability, not for the market value of an experiment. A team that can ship small changes frequently and stably does, however, lower the technical hurdle for short experiments and quick rollbacks.
An MVP that is only a reduced feature set saves build time once and pushes the risk to the back. An MVP as an experiment costs some discipline up front and makes the risk visible earlier. That is no guarantee of less friction or higher quality. But it separates the question “Can we deliver it?” from the more important question “Which assumption are we testing with it?”.
By the way, if you take the MVP as an experiment seriously, you think toward a viable architecture from the start. An approach such as evolutionary architecture with fitness functions fits exactly, because it accepts that the product evolves along what you learn – not along a plan nobody has tested.
Conclusion#
An MVP isn’t an amputated product. In my working definition, it is an experiment that honestly tests a risky assumption – the smallest version with which you can really test a hypothesis. A confirmatory test needs a learning question and a decision criterion set in advance; exploratory discovery may start more openly. Often that is a vertical slice through to the value, sometimes a concierge test or a landing page. “Minimal” refers to the necessary scope, not to carelessness. And it doesn’t even have to be code.
When a team switches from “the product, but less” to “the smallest version that honestly tests an assumption”, it isn’t the toolbox that changes but the guiding question. No longer “What else can we leave out?” but “What do we need to learn next, and what does the smallest honest test for it look like?”. This question doesn’t prevent wrong decisions, but it makes visible which learning is supposed to justify the next investment.
Further reading#
- Eric Ries, The Lean Startup (2011) – definition of the MVP, Build-Measure-Learn, validated learning, vanity vs. actionable metrics
- Steve Blank, “A minimum viable product is not always…” (blog, 2013) and The Four Steps to the Epiphany (2005) – customer development
- Melissa Perri, “Finding the Truth Behind MVPs” (2016) – concierge and Wizard-of-Oz MVP
- Nicole Forsgren, Jez Humble, Gene Kim, Accelerate (2018) – the four DORA metrics
- Neal Ford, Rebecca Parsons, Patrick Kua, Building Evolutionary Architectures (O’Reilly, 2017) – fitness functions
- Martin Fowler, “FeatureToggle” (2017) and trunkbaseddevelopment.com – feature flags and Trunk-Based Development
- Consumer-Driven Contracts (Fowler/Robinson, 2006) and the contract testing tool Pact
Revised and translated from German with the help of AI.