Back to BlogMVPs

What Should (and Shouldn’t) Go Into Your MVP

By Fadi Saadeldin · October 12, 2026

What Should (and Shouldn't) Go Into Your MVP

When teams start planning an MVP (minimum viable product), one of the most common mistakes is trying to fit too much into the first version. It's easy to think of an MVP as a smaller version of the final product. But that's not really the goal.

A good MVP is the smallest product you can build that answers one important question: does this solve a real problem for real users?

That distinction changes how you decide what belongs in version one, and what can wait.

What is an MVP?

MVP stands for minimum viable product. It's the simplest working version of your product that real people can use, built to show whether your idea is worth developing further.

Think of opening a restaurant. Before signing a lease and fitting out a kitchen, you could start with a food stall selling three dishes. If people queue up, you know it's worth expanding. If they don't, you've learned that quickly and cheaply.

Each word in the name matters:

  • Minimum: only what's needed for the main job, nothing extra.
  • Viable: it actually works and gives people real value.
  • Product: real users use it for real, not just look at a demo or a set of designs.

So an MVP isn't a prototype or a mock-up. It's a real product, just deliberately small.

Start with the problem, not the feature list

Before deciding what to build, define the main problem the product needs to solve. A strong MVP usually focuses on:

  • one clear user problem
  • one primary type of user
  • one core workflow
  • the essential features needed to complete that workflow
  • a simple way to collect feedback or measure usage

If a feature doesn't help the user complete the main task, or help you validate the idea, it probably doesn't need to be in the first release.

An example: scoping a booking platform

Take a type of product we work on: a SaaS booking platform for service-based businesses. The full vision is big. It includes an online booking engine for customers, a public website for each business, staff and schedule management, service and pricing management, automated WhatsApp messages, reporting, and eventually much more.

All of it is useful. Not all of it is needed to learn whether businesses and their customers actually want the product.

AreaVersion oneCan wait
PlatformWeb only, responsive on phonesNative iOS and Android apps
BookingChoose a service, pick a time, enter details, confirmPackages, memberships, waitlists
AdminManage services, staff and availabilityAdvanced reports and custom dashboards
MessagingBooking confirmation and a reminderMulti-step WhatsApp automation flows
RolesOwner and staffFine-grained permissions per location

The web-only decision alone saves a lot. A responsive web app works on any phone, ships updates instantly, and avoids maintaining separate codebases and app store reviews. If customers later ask for a native app, you build it knowing exactly what it needs to do.

What belongs in an MVP

The exact scope depends on the product, but good MVPs have a few things in common.

1. One clear user journey

The user should be able to enter the product, understand what to do, and complete the main task. In the booking example, that journey is: choose a service → choose a time → enter your details → confirm. That may be enough for the first version.

2. Only the essential features

Every feature should support the core workflow. Instead of asking "would this be useful?", ask "do we need this to validate the product?" Many features are useful. Very few are essential on day one.

3. A simple way to learn from users

An MVP should help you learn. Basic analytics, conversion tracking, error monitoring and a way to collect feedback are usually enough. You don't need a sophisticated analytics platform, just enough information to see whether people use the product as expected and where they get stuck.

4. A foundation that can grow

Building quickly doesn't mean building carelessly. This is where many fast MVPs fail: they validate the idea, then need a full rewrite to go further.

In practice, a solid foundation means a clean data model, a sensible and mainstream tech stack, and clear separation between the parts of the system. In the booking example, services, staff and bookings are modelled properly from day one, even if the admin screens are simple. Adding WhatsApp automation or a second location later then becomes an extension, not a rebuild.

Build for what the product needs today, while leaving reasonable room for tomorrow.

What can wait until after validation

Teams often spend a lot of time on features that could easily wait.

Native mobile apps. For most early products, a responsive web app is enough. Native apps add separate codebases, app store reviews and slower releases.

Complex dashboards. A basic admin view is usually enough at first. You don't need dozens of charts, filters and exports before you know whether users care about the core product.

Too many user roles. Every extra role adds permissions, workflows and testing. Start with the minimum the product needs to work.

Advanced automation. Some processes can be handled manually at first, sometimes called a "concierge" approach. Once you understand the real workflow and volume, automate the parts that need it.

Every possible integration. Each integration adds development and maintenance. Start with the ones genuinely required to validate the product.

Infrastructure for massive scale. Scalability matters; premature scalability usually doesn't. There is little value in designing for millions of users before you know you'll have hundreds.

Minimal doesn't mean rough

Cutting scope is not the same as cutting quality. If the booking flow is confusing or the confirmation never arrives, you aren't testing your idea. You're testing whether people tolerate a broken product.

The few features you do ship should feel clear, reliable and trustworthy. Fewer features, done properly, teach you far more than many features done halfway.

A simple rule for deciding what to include

The hard part of an MVP is rarely the code. It's deciding what not to build. For every feature, ask three questions:

  1. Does the user need this to complete the core workflow?
  2. Do we need it to test an important assumption?
  3. Is it cheap enough that leaving it out saves little?

If the answer is no to all three, the feature can probably wait.

How we approach MVPs at Yosemite

At Yosemite, we start with the product problem rather than the technology. We define the core workflow, remove unnecessary complexity, and build a focused first version that can be tested with real users, on a foundation designed to grow.

Once the product is validated, we expand the functionality, add automation and integrations, and evolve the architecture based on real requirements instead of assumptions.

Start focused. Validate early. Grow when the product gives you a reason to grow.

Have an idea you want to turn into a product?

Yosemite helps startups and businesses design, build and launch MVPs, web applications, mobile apps, e-commerce platforms and custom digital products.

Tell us about your idea at hello@yosemite.dev, and we'll help you work out what your first version really needs.

Have an idea?
Let's make it happen.

Starting from scratch, or improving something you already have? We'd like to hear about it.

We usually reply within one business day.