To build an MVP, pick the one thing your product must prove, build only that as real software, launch it to real users fast, and let what they actually do decide what you build next. An MVP, or minimum viable product, is the smallest version of your idea that a real person can use. A focused MVP usually costs $5,000 to $15,000 and ships in 3 to 6 weeks.
The point is to learn what works before you spend on the full build. We build MVPs for a living, and our fastest reached the app stores in under 21 days, in time to reach early users and investors. Here is the exact process, step by step.
What is an MVP?
An MVP is the smallest version of a product that still delivers real value and can be put in front of real users. It is not a rough demo or a clickable mockup. It is working software that does one important thing well, so you can test whether people actually want it before building everything else. The goal is learning, not completeness.
How do you build an MVP? (5 steps)
Every MVP we ship moves through the same five steps. The discipline is in step two, cutting, because that is what keeps an MVP small enough to ship fast and cheap.
| Step | What you do | Why it matters |
|---|---|---|
| 1. Define the one problem | Write the single core action a user must be able to take | Proves real demand before you spend |
| 2. Cut everything else | Remove anything not needed to deliver that action | Keeps cost and timeline small |
| 3. Build it as real software | Production React Native or Next.js, with only the accounts and payments it needs | You build on it later instead of starting over |
| 4. Launch to real users | Get it live and watch what people actually do | Real behavior beats any amount of planning |
| 5. Build the next part with data | Add features real users asked for, one at a time | Spending stays tied to what works |
Step 1: Start with the one problem you are solving
Before any code, get clear on the single problem your product solves and who has it. Most first-time founders want to build everything they imagined at once, and that is the fastest way to spend a lot and learn little. Write down the one core action a user must be able to take, the thing that proves people actually want this. That action is your MVP. Everything else waits.
Step 2: Cut everything else, ruthlessly
Once you have the core action, cut anything that is not needed to deliver it. Extra settings, a perfect design system, and rare edge cases can all wait. This feels uncomfortable, because every feature seems important. Ask a simple question of each one: if we launched without this, could a user still get real value? If the answer is yes, it is not part of the MVP.
Step 3: Build it as real software
An MVP is small, but it should still be real. We build MVPs as production software, in React Native for mobile or Next.js for web, with the accounts and payments they genuinely need to work. That way, when the idea proves out, you build on top of it instead of starting over. A demo held together with tape looks fine in a pitch and falls apart with real users.
Step 4: Launch, then learn
Getting it live is the whole point, because an MVP that never ships teaches you nothing. Put it in front of real users, or investors, and watch what they actually do. The signal you want is honest: are people using the core action and coming back? That is worth more than any amount of planning. Make sure you can measure it, even something as simple as counting how many people complete the core action.
Step 5: Build the next part with data
Once real people are using it, you have something planning never gives you, which is evidence. Now you build the next feature because real users asked for it, not because it was on the original wish list. This is how good products grow, one proven step at a time, and it keeps your spending tied to what actually works.
How much does an MVP cost?
A focused MVP usually costs between $5,000 and $15,000, depending on whether it needs accounts, payments, or a two-sided setup. Here is a rough breakdown. For the full picture, see what it costs to build a mobile app.
| MVP type | Cost range | Timeline |
|---|---|---|
| Single-feature MVP | $5,000 to $10,000 | 3 to 5 weeks |
| MVP with accounts and payments | $10,000 to $20,000 | 4 to 8 weeks |
| Two-sided or marketplace MVP | $20,000 to $35,000 | 6 to 12 weeks |
What should you include in an MVP, and what should you cut?
The rule is simple: include only what the core action needs, and cut the rest for later. Here is how that plays out for the features founders ask about most.
| Feature | In the MVP? | Why |
|---|---|---|
| The one core action | Always | It is the entire point of the MVP |
| Accounts and login | Only if the core action needs it | Skip it if a user can get value without signing in |
| Payments | Only if you are testing willingness to pay | Otherwise it is work that proves nothing yet |
| Custom design system | No | A clean, simple UI is enough to test demand |
| Admin dashboard | Minimal | A basic way to see and manage data is plenty |
| Settings, profiles, edge cases | No | Add these once real users actually ask |
What tools do you build an MVP with?
You do not need an exotic stack to ship an MVP. A small, proven set of tools covers almost every case, and it is the same one we use so the MVP can grow into the full product:
- React Native for mobile, so one codebase runs on both iPhone and Android. Here is [React Native vs Flutter](/blog/react-native-vs-flutter) if you are weighing the choice.
- Next.js for the web app or marketing site.
- A managed backend and database, so you are not building server plumbing from scratch for a first version.
- Stripe for payments, when the MVP needs to test whether people will pay.
- The App Store and Google Play for distribution, which we handle including the review.
How long does it take to build an MVP?
Most MVPs take 3 to 6 weeks, and our fastest reached the stores in under 21 days. The timeline follows the scope, so the smaller the first version, the sooner it ships. Here is how long it takes to build an app in more detail.
Common MVP mistakes to avoid
Most MVPs that fail do not fail because the idea was wrong. They fail because the build lost the plot. The usual mistakes:
- Building too much, so the first version takes months and costs the budget the real product needed.
- Polishing the design before proving anyone wants the thing.
- Shipping with no way to measure whether people use the core action.
- Building a throwaway prototype that has to be rebuilt the moment it works.
- Waiting too long to launch, so you learn nothing until it is expensive to change.
How we build MVPs
We scope the core with you and agree a fixed price before we start, then ship a real MVP you can put in front of users and investors. If the full product is more than you want to commit to now, that is exactly what an MVP is for. Start small, prove it, then grow.