Product

Why your MVP should do less than you think

Editorial · Reveneau · August 14, 2026 · Updated November 4, 2026

Why your MVP should do less than you think

Startups get an MVP built by one of five kinds of builder: a development agency or studio, freelancers, a technical co-founder, their first in-house engineers, or the founders themselves with no-code tools or AI coding assistants. Whoever builds it, the first version should do less than you think. Reveneau builds MVPs for startups: AI writes all of its code, and every change has to pass an eval suite written from the specification before it is released.

It is tempting to build more into a first version than it needs. The team cares about the product, so every feature feels important, and cutting any of them feels like releasing something unfinished. So the "minimum" product grows, and what was supposed to be a quick first version turns into a six-month build. Then it launches, and only then does the team find out whether the core idea worked at all. By that point the money and time are already spent. Your MVP should do less than you think, and that makes it stronger.

Who builds MVPs for startups?

Each kind of builder fits a different founder, and each leaves different work with you.

Builder Fits when What stays with you
A development agency or studio You want design and engineering from one team that owns the build Deciding the scope and answering the team's questions
Freelancers The scope is small and you can direct the work yourself The plan, the reviews, and putting the pieces together
A technical co-founder The product is the company and you need someone to own it for years A share of the company
Your first in-house engineers You have raised enough to hire and plan to build the product for the long term Hiring, which takes time before any work starts
The founders, with no-code tools or AI coding assistants You want to test the idea before you pay anyone Your own time, and a rebuild if the tool cannot grow with the product

Whichever you choose, settle three things in writing before work starts:

  • Who owns the code. Under US copyright law, the author of a work is ordinarily the person who created it. The US Copyright Office's Circular 30 (revised August 2024, read 4 November 2026) lists nine kinds of commissioned work that can be "made for hire" under a signed agreement, and computer programs are not among them. So the code an outside builder writes becomes yours through a transfer of the copyright, and 17 U.S.C. 204(a) (read the same day) says a transfer is valid only when it "is in writing and signed by the owner of the rights conveyed". Keep the code in a repository you control from the first day. The guide on who owns code a partner or an AI writes explains the rules.
  • What the first version includes. Agree a fixed scope and a written list of what was cut, for the reasons in the rest of this post.
  • How each change is checked. Ask how every change is tested before it reaches users, and who writes the tests.

Reveneau works this way. AI writes all of its code, and every change has to pass an eval suite written from the specification. We use AI instead of hiring more engineers, so the build takes a small team, and that saving goes into your price. See how we work with startups.

What is an MVP for?

Start with what an MVP is for, because the name confuses people. Minimum viable product sounds like "the cheap version of the real thing." An MVP is a tool for learning, as fast as possible, whether your idea works.

That changes how you build it. If an MVP were a small version of the full product, you would want it to be as complete as you could afford, and every feature you added would make it better. A learning tool has a different job: get you real evidence about the core idea as quickly as possible. Judged that way, extra features make the MVP slower to build and slower to teach you anything, which makes it worse at its job. Once you see the MVP as a way to reach the truth quickly, cutting features stops feeling like a loss.

Every feature you add before launch delays learning

Every feature you add before launch delays the day you learn whether the product works.

The logic is simple. Each feature takes time to build and test before you can launch. Until you launch and real users touch the product, everything you believe about it is a guess. So each feature you add is more time spent guessing and less time spent learning. A team that adds ten features to its first version has delayed the moment it learns the answer by however long those ten features took, while risking all of that time on assumptions it has not tested. If the core idea turns out to be wrong, all of that extra effort was spent making a wrong thing more elaborate.

This is why a big first version hides risk. Launching something complete feels safer, and it is riskier, because you have committed more before learning anything, and you find out later, when changing direction is most expensive. A smaller MVP feels risky and is safer, because it gets you to real feedback while you can still act on it cheaply. We made a version of this argument about custom builds in general in build vs buy: the research on large software projects is direct, and the pattern holds here too. Bigger means more risk. Smaller means more safety.

How do I decide what to cut from an MVP?

Knowing you should do less is easy. Cutting is hard, and it is a discipline you have to practice deliberately, because the pressure always pushes the other way.

The tool that helps most is a single question you ask of every proposed feature: can the product teach me what I need to learn without this? If the answer is yes, the feature waits until after launch. The decision is narrow: the feature is not required to test whether the core idea works, so it does not belong in the version whose only job is to run that test. Features that feel essential before launch often fail this question. The extra settings, the second user type, the final details on flows nobody has even reached yet, the integrations you assume people will want. Each one feels necessary, and few of them are needed to learn the one thing you are launching to learn.

A practical trick makes the cutting easier: keep a "later" list. Every feature you cut goes on it, written down, waiting for evidence. This matters because the resistance to cutting comes from fear of losing the idea. Write it down and the fear goes away, and the team stops arguing to keep features in the launch because they can see the features are safe on the list. Tie each item to the question it would help answer, and you will find that many of them are answering questions you do not even have yet.

Do one thing, and do it well

When you reduce an MVP, the one thing that remains, the core reason the product is worth using, should be done well. That is the thing you are testing, so it has to be good enough to give an honest test.

Think of it as concentrating your quality instead of spreading it across many features. A full first version spreads a fixed amount of effort across many features, so everything is rough. A small MVP puts that same effort behind the one thing that matters, so that one thing is good, and the rough or missing pieces are all in the parts that do not matter yet. Users forgive a lot of missing features if the core does its job well. They do not forgive a weak core no matter how many features surround it. So the rule is "do one thing, and do that one thing well." Find the single core action that makes the product worth using, make that excellent, and let everything else be rough or absent for now.

After launch, let evidence decide

The MVP starts a cycle. You release the small version, you watch how real users behave, you learn what they value, and you add only what the evidence says matters. Adding features after launch is fine and expected. The discipline is to wait for evidence before you add them. After launch, you have evidence, so adding is informed instead of a guess.

This is what makes doing less worth it. The team that launched small is now learning from real behavior, adding the features users use, and dropping the ones from the "later" list that nobody ever missed. The team that launched big is still discovering, weeks later, that half of what they built goes unused, and now they own all of it: the maintenance, the complexity, the code that has to keep working even though it earns nothing. Small got the answer faster and has less to maintain. That is the whole case for doing less: it is the fastest honest way to know whether the thing you are building is worth building further. If you want a team that will encourage you to cut rather than add more, that instinct is central to how we approach a full product build.

The argument for a small MVP got stronger once building became cheap. When building was expensive, "build less" was partly a budget argument, and a team with more funding could reasonably ignore it. That budget argument is gone: you can now afford to build the large version.

You still should not. Every feature in an MVP is something to explain, support, and keep working, and each one adds a place where user feedback about the core idea gets mixed up with feedback about a less important one. An MVP stays small so that what you learn from it means something.

Sources

Common questions

Who builds MVPs for startups?

Startups get an MVP built by a development agency or studio, by freelancers, by a technical co-founder, by their first in-house engineers, or by the founders themselves with no-code tools or AI coding assistants. Whoever builds it, put in writing who owns the code and what the first version will include.

What is an MVP?

An MVP, or minimum viable product, is the smallest version of a product that you can give to real users to learn whether it works. It is a tool for learning fast, which means it should do as little as possible while still testing the core idea.

Why should an MVP do less?

Because every feature you add before launch delays the day you learn whether the product works, and adds risk that something breaks or distracts from the core. A smaller MVP reaches real users sooner, which means you learn sooner.

What is the one thing an MVP must do well?

It must do the single core thing that makes the product worth using, and do that one thing well. Everything else can be rough or missing. If the core is weak, no amount of surrounding features will save it, and if the core is strong, users will forgive a lot of unfinished parts.

How do I decide what to cut from an MVP?

For each feature, ask whether the product can teach you what you need to learn without it. If yes, cut it for now. Keep only the features required to test whether the core idea works. Much of what feels essential before launch turns out to be something you can add later, once you know it matters.

Does a smaller MVP mean lower quality?

No. The one core thing your MVP does should be done well, because that is what you are testing. A small MVP concentrates your quality on the part that matters instead of spreading it across features nobody asked for yet.

Why does adding features delay learning?

Because each feature takes time to build and test before you can launch, so every feature delays the day real users touch the product. Until real users touch it, you are guessing. More features means more time guessing and less time learning, which is the wrong order for a first version.

What is the risk of launching with too many features?

You spend months building things you assumed users wanted, launch, and discover the core idea was wrong or that users only care about one part. Now you have wasted the effort on the extra features and delayed the feedback that would have told you sooner. A big first version hides that risk.

How is an MVP different from a discovery prototype?

A discovery prototype tests a risky assumption cheaply, often before writing real code, and you usually throw it away. An MVP is a real, released product, a small one that real users use so you can learn from their behavior over time. The prototype comes first, the MVP is the first real version.

What should I do after launching a small MVP?

Watch how real users behave, learn what they value, and add only what the evidence says matters. The MVP is the start of a cycle: release, learn, adjust. Adding features after launch is fine and expected; the discipline is to wait for evidence before you add them.

How do I resist the pressure to add just one more feature?

Remind yourself and your team that every added feature delays the day you learn the truth. Tie each proposed feature to a question it helps answer, and if it does not help you learn whether the core works, it waits. Writing the cut features on a "later" list helps, because each one is written down and waits there.

Can a small MVP compete with a full-featured product?

At the start your goal is to learn whether your core idea is worth building further. A small MVP that does one thing well and teaches you fast is worth more early on than a full product built on assumptions you never tested.

Start a project