8 June 2026
What “MVP” Gets Wrong
The MVP has been corrupted into two opposite failures: shipping junk and calling it lean, or building everything and calling it minimum. What it should actually be.
The term “MVP” has been worn down until it means almost nothing, and the two ways people get it wrong are exact opposites. One camp ships something broken and embarrassing, calls it minimum, and wonders why nobody wants it. The other camp builds nearly the whole product, calls it minimum because they cut two features, and wonders where the budget went. Both miss the actual point, which has nothing to do with how big or small the thing is. An MVP is the smallest thing that does one real job well enough to start earning — money, users, or genuine learning — and most of what gets called an MVP fails on either “smallest,” “real job,” or “well enough.”
I care about getting this right because the MVP, done properly, is the most powerful move in software economics. It’s how you bank value in year one instead of year three, and how you compound from a working thing instead of betting everything on a big launch. Done wrong in either direction, it’s just a worse way to waste money. So it’s worth saying plainly what the word should mean and why the two failure modes are both expensive.
Failure one: minimum as an excuse for bad
The first corruption reads “minimum viable” as permission to ship something half-built and unpolished, on the theory that it’s only an MVP so quality doesn’t count yet. This is where you get the product that technically exists, technically does the thing, and is so rough that the first users bounce and never come back — and then the team concludes the market wasn’t there.
The word doing the damage is “viable.” Viable means it actually works for its one job — well enough that a real person gets real value and would come back. Minimum constrains the scope; viable constrains the quality of what’s in scope. You can have very few features, but the ones you have must genuinely work, because the entire purpose is to find out whether people want the thing, and you cannot learn that from a version so broken it can’t tell you. “Minimum” was never a license to ship junk. It was a license to ship little — and what little you ship has to be real.
Failure two: minimum as the whole product minus a haircut
The opposite failure is more expensive and more common among teams that should know better. “Minimum” gets stretched to mean “the full product with a couple of nice-to-haves deferred,” and the MVP turns into a six-figure, nine-month build of nearly everything before a single customer has touched it or paid a penny.
This defeats the entire reason the MVP exists. The point is to get a real, working slice in front of real users and into earning fast — to find out what’s true and start the ROI clock before you’ve sunk the big money. Build almost the whole thing first and you’ve taken on the full cost and the full risk of being wrong, and learned nothing earlier than you would have anyway. The discipline that makes an MVP an MVP is ruthless scoping: deciding what the one job actually is and refusing to build anything that isn’t that one job, however reasonable each extra thing sounds on its own. Every feature you defer is risk you don’t carry and money you don’t spend until you know it’s worth spending. A “minimum” that’s most of the product is just a normal big-bang build with a fashionable label.
The real test: does it do one real job well enough to start?
Strip both failures away and what’s left is the actual definition, and it’s a sharp one. An MVP does one real job — not five, the one that matters most — and does it well enough that a real user gets real value, which means it earns: revenue, retention, or a clear answer to the question you built it to ask. Smallest, real job, well enough. Get all three and you have an MVP. Miss any one and you have something else wearing the name.
That definition is demanding in a way the lazy version isn’t. It forces you to decide what the one job is, which most teams avoid because it means saying no to things they’d rather keep. It forces real quality on a tiny surface, which is harder than shipping rough or building broad. The reason it’s worth the difficulty is the compounding: a true MVP that earns gives you a working asset, real money or real learning, and a clear next thing to build — and you grow from there, each step funded and informed by the last. That’s the whole game, and the two failure modes both forfeit it.
Where a fuller first build is honestly right
The honest counter: the minimal version isn’t always viable, and pretending otherwise is its own failure. Some products have a real floor below which they genuinely don’t work — a payments platform that has to be secure and correct on day one, something regulated, something where the smallest useful version is genuinely substantial because the job itself is. There, “viable” sets a higher bar than usual and the MVP is bigger, not because you padded it but because the one real job is large.
But that’s a much rarer case than people claim, and “ours is special” is the most common excuse for the build-everything failure. The discipline is to assume the MVP is small and make the problem prove it needs to be bigger — not assume it’s big and call the whole thing minimum. Most products that “need” the full build first didn’t; someone just didn’t want to do the hard scoping work, and “it’s all essential” was easier than deciding what actually was.
What this means for you
If you’re about to build, the most valuable hour you’ll spend is the one where you decide what the single real job is and cut everything that isn’t it — and then hold that line while everyone, including you, argues for adding just one more thing. Ship that small real thing, well enough to earn, and let what you learn and what you bank fund the next step. Don’t ship junk and blame the market. Don’t build everything and call it lean. Build the smallest real thing that works, get it earning, and compound.
That’s also how the rest of my thinking actually becomes possible: you can only build-don’t-rent and own the thing yourself if the build is small enough to be worth it, and the MVP is the discipline that keeps it small.
This is one of my essays — simplicity is the senior move is the same instinct aimed at how you build rather than how much, and why most internal software should be built, not bought is what the MVP makes affordable. If you want this turned into a procedure, how to scope an MVP walks the actual cut; if you want the term settled cleanly, what an MVP actually is is the definition.
If you’re scoping a build and want help finding the one real job before you spend the money, tell me about it. And if the thing you actually need is a full product built and run by a team past the MVP, that’s what my agency, Digital Royalty, is for.