Your MVP Should Be a Test, Not a Wishlist

A founder once described an MVP to me that had dashboards, integrations, automation, permissions, notifications, analytics, AI features, and three different user roles.

I asked one question:

“What is the smallest version a real customer could use to solve the core problem?”

There was a pause.

Because somewhere along the way, the MVP had stopped being an MVP.

It had become a smaller version of the final product.

And those are not the same thing.

Welcome to #MVPDecisionRoom.

Today’s decision:

What actually belongs in the first usable release?

#MVPScoping


An MVP is not a tiny version of your dream product

I like to think about an MVP the way I think about opening a restaurant.

Imagine someone tells you:

“Before we serve our first customer, we need a 120-seat dining room, loyalty program, delivery app, private event space, custom lighting system, and three locations.”

You would probably ask:

“Have we served anyone dinner yet?”

Software teams do the equivalent all the time.

They build infrastructure for customers they do not yet have.

They automate workflows nobody has validated.

They create configuration options before they know what customers actually want to configure.

They design for scale before proving demand.

Then six months later, everyone is exhausted and the most important question is still unanswered:

Will people consistently use and pay for this product?

That is why I define an MVP differently.

An MVP is not the smallest product you can technically ship.

It is the smallest usable product that can produce meaningful evidence.

Those last two words matter.

Meaningful evidence.


“Minimum” does not mean incomplete

This is where MVP conversations often go wrong.

Teams hear “minimum” and imagine something broken, ugly, or barely functional.

That is not what I mean.

A first release can be narrow while still being complete.

Suppose I am building a scheduling product for a specific type of business.

The full vision may include:

  • automated reminders
  • payment collection
  • team scheduling
  • customer portals
  • reporting
  • calendar integrations
  • AI scheduling assistants
  • analytics
  • CRM integrations
  • mobile apps

But perhaps the first meaningful job is simply:

A business owner can create availability, a customer can book a slot, and both know the appointment exists.

That workflow can be complete.

It just does not need to solve every neighboring problem yet.

That distinction is critical.

A weak MVP feels unfinished.

A well-scoped MVP feels focused.


I usually start with one question

Before discussing features, architecture, frameworks, or AI agents, I want to know:

What must happen for the customer to experience the core value?

Not what would be nice.

Not what competitors already have.

Not what might be useful next year.

Not what someone mentioned during a brainstorming session.

What must happen?

Imagine drawing the customer journey as a bridge.

On one side:

The customer has a problem.

On the other:

The customer has achieved the desired outcome.

Your first release only needs enough bridge to get the right customer safely across.

Everything else can wait.


The first usable release should prove something important

This is why MVP scoping is really a decision-making exercise.

You are not simply cutting features.

You are deciding which uncertainties deserve to be tested first.

For example, you may need to learn:

Will customers actually use this workflow?

Will they return?

Will they invite colleagues?

Will they pay?

Can the product fit into the customer’s current process?

Will they trust the output?

Does the product save enough time or money to justify switching?

Those questions are much more valuable than:

“Can we build Feature X?”

Most competent teams can build Feature X.

The harder question is whether Feature X contributes to something customers actually care about.


I separate MVP features into three buckets

When I work through MVP scope, I find this simple classification useful.

1. Must exist

Without these capabilities, the core workflow simply does not work.

They are essential to delivering the primary value proposition.

2. Helps learning

These features help us validate an important assumption.

Maybe we need payment functionality because willingness to pay is one of the hypotheses.

Maybe we need collaboration because adoption depends on multiple team members.

Maybe we need an integration because customers cannot realistically use the product without it.

These features earn their place because they help us learn.

3. Can wait

This is usually the biggest category.

Advanced analytics.

Deep customization.

Multiple themes.

Complex admin controls.

Edge-case workflows.

Secondary integrations.

Automation that replaces a manual process we have not even validated yet.

These things may eventually matter.

But “eventually” is very different from “now.”


One of my favorite MVP questions is surprisingly uncomfortable

I often ask:

“What could we do manually for the first 10 customers?”

That question makes technical teams uncomfortable because engineers naturally want to automate.

I understand that instinct.

I am technical too.

But manual work can be extremely useful early on.

Suppose the product eventually needs sophisticated onboarding automation.

Do we need to automate it immediately?

Maybe not.

The first customers might be onboarded manually.

Why?

Because those conversations may teach us more than the automated system ever could.

We see where customers hesitate.

We discover terminology they do not understand.

We notice what information they provide incorrectly.

We learn what they expect to happen next.

Only then do we automate.

Otherwise, we risk automating the wrong workflow beautifully.


The same applies to architecture

There is another extreme I often see.

The MVP starts with:

“Let’s build for 10 million users.”

That sounds ambitious.

But if there are currently zero users, I have a different priority.

I want an architecture that is:

simple enough to move quickly, structured enough to evolve, and deliberate enough to avoid obvious dead ends.

That does not mean ignoring scalability.

It means separating future-aware architecture from premature architecture.

You should understand what happens if the product succeeds.

You should know which decisions will be painful to reverse.

You should leave reasonable expansion paths.

But you do not need to build every future system today.

A good architect does not build ten empty floors because a company might eventually hire 5,000 people.

They make sure the building can support expansion when the evidence justifies it.


Here is the trap: every feature has a lawyer

During MVP planning, almost every feature has someone who can explain why it is necessary.

“We need advanced reporting because enterprise customers expect it.”

“We need roles and permissions because eventually there will be teams.”

“We need ten integrations because customers use different systems.”

“We need AI because competitors have it.”

“We need mobile because people use phones.”

Individually, each argument sounds reasonable.

Together, they create a 12-month MVP.

This is why MVP scoping cannot be done one feature at a time.

You have to evaluate features against the product hypothesis.

The question becomes:

Does this feature help the first customer achieve the core outcome or help us validate a critical assumption?

If not, it probably belongs in a later release.


There is another reason smaller MVPs win: they preserve flexibility

Early product development is full of unknowns.

You may discover that the buyer you expected is not the real buyer.

The workflow might be different.

The pricing model might change.

The most valuable use case might shift.

The feature customers love may be something you originally considered secondary.

Large MVPs create commitment before learning.

Small, focused MVPs preserve options.

And optionality is incredibly valuable when uncertainty is high.

Think of it like navigating a foggy road.

You do not need headlights powerful enough to see 50 miles.

You need enough visibility to safely reach the next turn.

Then you reassess.


My practical test for MVP scope

When I look at a proposed first release, I ask:

Can a real target customer complete the core job?

If no, the scope is too small.

Can we learn something meaningful from their behavior?

If no, the release may not test anything important.

Are we building features primarily because we might need them later?

If yes, the scope may be too large.

Could some operations remain manual temporarily?

If yes, we may be able to reduce complexity.

If the MVP succeeds, do we have a reasonable path forward?

If no, we may be creating unnecessary technical debt.

That is the balance.

Not minimalism for the sake of minimalism.

Not overengineering for the sake of safety.

A focused experiment wrapped inside a usable product.


The most expensive feature may be the one nobody needed yet

Founders often worry about leaving something out.

I worry just as much about putting too much in.

Because every feature creates more than development work.

It creates:

testing.

documentation.

support.

maintenance.

dependencies.

UX decisions.

security considerations.

future migration problems.

Every feature becomes luggage.

And early-stage products need to move quickly.

Before adding another suitcase, I want to know whether we are actually going on that trip.


So what should the first usable release look like?

For me, a strong first release usually has five characteristics:

It solves one important problem.

It serves a clearly defined customer.

It enables a complete core workflow.

It generates evidence about important assumptions.

And it creates a credible path to the next release.

That is enough.

Not because the vision is small.

But because the sequence is disciplined.


The MVP Decision Room question

If you are building a product right now, try this exercise.

Write down every feature currently planned for the first release.

Then ask of each one:

“What happens if we remove this?”

If the core customer outcome collapses, keep it.

If an important hypothesis can no longer be tested, probably keep it.

If the answer is:

“Well… we will probably need it later.”

You may have just found something for Version 2.


The best MVPs I see are rarely the ones with the most features.

They are the ones with the clearest reason for every feature that survived the cut.

That is what good MVP scoping is really about.

Not building less.

Learning sooner.


What would I like the LinkedIn community to add?

If you have built, launched, funded, sold, or scaled an MVP, I would like to hear your perspective:

What is one feature you thought was essential in Version 1 — but later realized could have waited?

Your answer may save another founder a few months of development.


If you are deciding what belongs in your first release, I help founders turn business problems into a focused MVP strategy — from scope, requirements, and architecture to product development, positioning, GTM, and the path toward scale.

If you have an MVP that keeps getting bigger every time someone opens the roadmap, click here to reach out to me.

I am happy to help you separate:

what must be built now
from what simply deserves to exist someday.

#MVPDecisionRoom #MVPScoping #MVP #ProductStrategy #SaaS #B2BSaaS #ProductDevelopment #Founders #StartupStrategy

Bring the question into your business

If this article reflects a decision you are facing, share the context. We can explore whether a focused conversation or engagement would help.

Start a Conversation →