How to Scope an MVP
Scoping an MVP is one ruthless cut, made with one question: what is the smallest thing that solves the actual problem for one real user? Everything that survives that question is in. Everything else waits — not deleted, not forgotten, just not now. The hard part isn’t knowing this. It’s having the discipline to cut the features you’re attached to, and that’s where almost every MVP scope goes wrong.
That’s the answer. Here’s the question in full, why “minimum” and “viable” pull against each other on purpose, and how to cut without gutting the thing.
The whole job is one cut
An MVP is not a small version of the full product. It’s the smallest thing that delivers the core value to someone real and lets you start learning and earning. Those are different — a small version of everything is still everything, just worse. The MVP is one thing done properly: the single workflow that is the actual point, built well enough to use, with everything around it stripped away.
The reason this is hard is that every feature feels essential when you’re the one who imagined it. You can see how each piece connects to the vision, so cutting any of it feels like cutting the vision. It isn’t. The vision survives the cut completely — it just gets built in the order that solves the real problem first and banks the value first, instead of all at once with the value arriving last. Scoping an MVP is the act of separating “the thing that makes this worth existing” from “the things that make it complete,” and shipping the first without waiting for the second.
If you can’t bring yourself to cut, you don’t have a scoping problem, you have an attachment problem, and it will cost you months. The whole discipline is being willing to ship something that feels incomplete because it solves the real problem, instead of something complete that took three times as long to start earning.
The one question, applied
Here’s how I actually run the cut. Take every feature on the list and ask, of each one: if this weren’t here, would the core problem still get solved for one real user? If the answer is yes — it still works without this — the feature waits. Not forever. Just not in version one.
The user accounts system, the admin dashboard, the settings page, the notifications, the third payment option, the reporting, the onboarding flow, the dark mode — apply the question to each and most of them fall to “the core still works without it.” They’re real, they matter eventually, and none of them is the point. The point is usually one workflow: the thing the user came to do. Build that workflow end to end, well enough that a real person can complete it and get value, and you have an MVP. Everything you cut is your roadmap, in priority order, already written.
The mistake is applying the question softly — “well, it’d be much better with this.” Of course it would. Better is not the bar; solves the real problem is the bar. The MVP is allowed to be worse than the eventual product in every way except the one that matters. Hold the bar where it is and the cut makes itself.
Minimum and viable are supposed to fight
The two words pull in opposite directions and that tension is the entire skill. Minimum pulls toward cutting everything. Viable pulls toward keeping enough that the thing actually works for someone. Scope too far toward minimum and you ship something that technically exists but solves nothing — a login page with nothing behind it. Scope too far toward viable and you’ve rebuilt the full product and called it an MVP.
The line between them is “solves the real problem for one real user.” Below that line, you’ve cut into the muscle — the thing doesn’t deliver the core value any more, and you’ve shipped a demo, not a product. Above that line, you’re carrying weight you didn’t need to ship. Find the lowest point at which a real user gets the real value, and stop there. That’s viable. Everything below is too thin; everything above is too soon.
Scope it to be owned and extended, not to be thrown away
Here’s where this connects to everything I believe about building. An MVP is not a throwaway prototype you’ll bin and rebuild — that’s a waste, and it’s how people end up paying for the same thing twice. The MVP is the first version of a system you own and compound from. So you scope it small, but you build the small thing properly, on foundations you can extend.
That changes the cut slightly. You cut features hard, but you don’t cut quality on the features that survive, and you don’t build the core in a way you’ll have to tear out next month. The data model that the one workflow runs on is the data model you’ll build everything else on — get that right even when everything around it is deferred. The reason to MVP isn’t to ship something disposable fast; it’s to start owning a working system fast, bank the value, and grow it. Build the smallest thing, but build it like you’ll keep it, because you will.
A pattern I see
The recurring one: a founder with a genuinely good idea and a feature list two pages long, every item of which they can justify. They want to build all of it before launch because they’re afraid that without feature X, nobody will use it. So they spend nine months and a lot of money building a complete product, launch it, and discover that users only ever touch one workflow — the one that was the actual point — and ignore most of the rest.
They built the whole thing to find out what the MVP was. The MVP was that one workflow all along. Had they scoped to it, they’d have launched in two months, learned the same lesson for a fifth of the cost, and spent the other seven months building what users actually asked for instead of what they’d guessed. The long feature list wasn’t ambition. It was uncertainty, and the cure for uncertainty is shipping the core fast and letting real users tell you what’s next — not guessing it all in advance and building blind.
Who this isn’t for
If you genuinely can’t reduce your product to a core workflow — if it only delivers value when every part exists at once, which is rare but real in some regulated or deeply integrated systems — then forcing an MVP scope produces something that solves nothing, and you should plan a fuller first build instead. This is for the large majority of products that have a clear core and a lot of deferrable around it.
The call, in one line
Cut everything that isn’t the one workflow that solves the real problem — build that properly, ship it, and let the rest become your roadmap.
This is one of my playbooks. It sits directly behind build or buy? — the MVP-first math is why building lean beats renting — and how to evaluate a software quote, because a well-scoped MVP is the only thing worth getting quoted. If you want to know what the term itself really means and when it applies, what an MVP actually is covers the definition.
If you’ve got a feature list and want help making the cut for your specific product, talk to me — deciding what to leave out is usually a one-conversation job that saves months. And if the thing you’re scoping turns out to need a full team to build and run from day one, that’s what my agency, Digital Royalty, is for.