MVP Roadmap: What to Build First and What to Skip
How to prioritize MVP features, avoid scope creep and launch faster: a practical framework to build what matters and skip what does not.
- LaunchMap editorial team
- Updated
- Published
- 17 min read
On this page
- What an MVP actually is (and what it isn't)
- MVP build options by budget and skill
- Why most founders overbuild their MVP
- The core value test: finding your one thing
- The MVP feature prioritization framework
- The "what to skip" checklist
- How to build an MVP: a week-by-week roadmap
- MVP plan and roadmap template
- Real-world MVP examples that got it right
- Common MVP roadmap mistakes
- From MVP to product-market fit
- Conclusion
- Frequently asked questions
Test your idea in about 30 seconds
Map my ideaThe graveyard of failed startups is full of products that had too many features and not enough users.
Building a Minimum Viable Product should be simple in theory: ship the smallest thing that delivers value, learn from real users, iterate. In practice, most founders add "just one more feature" before launch. They build admin dashboards before they have admins. They spend weeks perfecting onboarding for users who have not signed up yet, and end up with a bloated first version that took six months instead of six weeks and still missed what customers wanted.
This guide is a practical framework for building your MVP roadmap: which features belong in your first version, which ones to defer, and a development plan that gets you to launch fast without shipping something useless.
One rule makes the rest easier: test demand before you build. The free business idea validator names the riskiest assumptions behind your idea, with a cheap test for each, in about 30 seconds and without a sign-up, so the MVP you plan solves a problem people have already confirmed.
What an MVP actually is (and what it isn't)
Let's recalibrate the definition, because it's one of the most misunderstood concepts in the startup world.
An MVP is the smallest version of your product that lets you test your core value proposition with real users. That's it. Not the smallest version of your dream product. Not a prototype with placeholder UI. Not a landing page with no functionality.
Here's what an MVP is NOT:
- Not a demo. A demo shows what your product could do. An MVP does the thing, even if it's rough.
- Not a feature list. If you're thinking in features, you're already off track. Think in outcomes.
- Not your final product. It will be embarrassing. That's the point. If you're not slightly uncomfortable shipping it, you waited too long.
- Not "minimum" as in broken. Viable matters. It has to actually work and deliver value, even if it only does one thing.
Reid Hoffman's famous quote applies here: "If you're not embarrassed by the first version of your product, you've launched too late." But embarrassment should come from missing features, not from a broken core experience.
MVP build options by budget and skill
How you make a minimum viable product depends more on your budget and skills than on the idea: with no code and almost no money you can run a concierge or Wizard of Oz MVP, and with a few weeks and a monthly subscription you can ship a no-code app.
The table runs from the cheapest test to the biggest build. The first two rows are demand tests rather than MVPs, because nobody receives the outcome yet, but they are the cheapest way to decide whether to build at all. Times are our rules of thumb for one founder with a few focused hours a day, not benchmarks.
| Option | Skill you need | Time to build | Cash cost | What it proves |
|---|---|---|---|---|
| Landing page plus waitlist | None beyond clear copy | 1 to 2 days | About $19 a year with Carrd Pro Standard, plus any ad budget | People want the promise, not yet that they will pay or use it |
| Pre-order | None | 1 to 3 days | 2.9% + 30¢ per US card sale with Stripe Payment Links, no monthly fee | People pay before the product exists |
| Concierge | The skill to deliver the result yourself | 1 to 3 days to set up | Mostly your time | The outcome is worth paying for, and what the work involves |
| Wizard of Oz | Basic no-code | 3 days to 2 weeks | A page or no-code front end, plus your time on every order | People use it as if it were automated |
| No-code app | Comfortable with spreadsheets and app builders | 1 to 4 weeks | $0 to build, about $25 to $50 a month on a paid plan to launch | People come back and use it on their own |
| Single-feature code build | You or a co-founder can code | 2 to 6 weeks | Mostly developer time, plus card fees once you charge | The core loop works and keeps users |
Pick the cheapest row that can kill your riskiest assumption. If the risk is demand, a landing page or a pre-order answers it in days. If the risk is whether the outcome is worth paying for, deliver it by hand as a concierge or Wizard of Oz MVP. Build software, with no-code or code, once people keep coming back to the manual version and the manual work becomes the bottleneck.
The prices behind the table were checked on November 10, 2026 on each company's pricing page. Carrd Pro Standard costs $19 a year and adds forms, which a waitlist needs, and a custom domain. Stripe charges no setup or monthly fee and includes Payment Links; a successful US card payment costs 2.9% plus 30 cents, with 1.5% more for international cards. Softr's free plan allows apps with up to 5 logged-in users, and its Basic plan, which adds a custom domain, costs $25 a month or $19 a month billed yearly. Bubble's free plan has no live website or custom domain, and its Starter plan costs $39 a month or $32 a month billed yearly. On Glide, publishing a public app takes the Plus plan at $50 a month.
Pre-orders come with obligations. If you pre-sell a physical product in the US, the FTC's Mail, Internet, or Telephone Order Merchandise Rule applies: ship within the time you promised, or within 30 days if you promised no date, and if you cannot, offer each buyer the choice of agreeing to a delay or cancelling for a prompt refund. The rule covers merchandise, not services. This is a summary of the FTC's guide, not legal advice.
Why most founders overbuild their MVP
Before we get into the framework, let's understand why scope creep happens. It's not because founders are bad planners. It's because of predictable psychological traps:
Fear of judgment. You imagine a user trying your product, hitting a missing feature, and thinking, "This is amateur." So you add more features to prevent that reaction. But the real risk isn't looking incomplete. It's spending months building something nobody wants.
Comparison with incumbents. You look at established competitors with 5 years of development and 50 engineers, and you think your v1 needs to match their feature set. It doesn't. You need to beat them on one thing for one audience.
Building for imaginary users. Without a clear Ideal Customer Profile, you build for everyone. And building for everyone means building everything. This is why defining your ICP first is a prerequisite to a good MVP roadmap.
Confusing complexity with value. More features don't mean more value. Often, the opposite is true. A focused product that solves one problem well converts better than a Swiss Army knife that solves ten problems poorly.
No structured plan. When you start building without a roadmap, every idea that pops into your head feels urgent. A written plan acts as a filter: anything that is not in it waits.
The core value test: finding your one thing
Every successful MVP is built around a single core value loop. Before you list any features, answer this question:
What is the one thing my product does that makes a user's life measurably better?
Not two things. Not three. One.
Here are examples:
| Product | Core Value Loop |
|---|---|
| Dropbox | Save a file on one device, access it on another |
| Airbnb | List your spare room, get paid by travelers |
| Stripe | Accept payments on your website with a few lines of code |
| Calendly | Share a link, let people book time without email back-and-forth |
Notice that none of these describe a feature set. They describe an outcome. Your MVP needs to deliver that outcome, and everything else is optional for v1.
How to identify your core value loop
Ask yourself:
- What problem did my ICP describe as most painful in customer discovery interviews?
- What's the one action a user takes in my product that delivers the "aha moment"?
- If I could only build one screen (or one workflow), what would it be?
- What would make a user come back tomorrow?
If you ran customer interviews, reread the notes: the pain people described most often, in their own words, is your anchor. If you have not run them yet, the customer interview questions generator gives you a script that asks about past behavior instead of opinions.
The MVP feature prioritization framework
Once you know your core value loop, you need a system to decide what makes the cut and what doesn't. Here's a practical four-tier framework.
Tier 1: Must have (launch blockers)
These are features without which your product can't deliver the core value. If you remove any of them, the product stops working.
The test: "Can a user complete the core value loop without this?" If no, it's Tier 1.
Examples for a hypothetical invoicing tool for freelancers:
- Create an invoice
- Add line items with descriptions and amounts
- Send invoice via email or shareable link
- Mark invoice as paid
That's it. That's the MVP for an invoicing tool. Everything else is Tier 2 or below.
Tier 2: Should have (week 2-4 post-launch)
These features enhance the core experience but aren't required for the first version. Users can work around their absence.
The test: "Will users ask for this in the first week?" Probably yes. "Will they leave without it?" Probably no, if the core works well.
Examples:
- PDF export of invoices
- Recurring invoices
- Dashboard with payment status overview
- Email reminders for overdue invoices
Tier 3: Nice to have (month 2-3)
These features add polish and expand use cases. They're driven by user feedback, not assumptions.
The test: "Am I building this because users asked for it, or because I think it's cool?"
Examples:
- Multiple currency support
- Integration with accounting software
- Custom branding on invoices
- Client portal
Tier 4: Not now (backlog)
These are features that feel important but don't serve your ICP's core problem right now. They often represent a different market segment or a future product expansion.
The test: "Does this serve my current ICP, or a future audience I haven't validated yet?"
Examples:
- Team collaboration features
- API for third-party integrations
- Mobile app
- AI-powered financial insights
Putting features into Tier 4 isn't killing them. It's protecting your focus.
Check the numbers before you build: a feature that takes a month of work has to earn that month back. The break-even calculator shows how many sales a month your price needs, and the startup cost calculator adds up what you will spend before sales cover your costs.
The "what to skip" checklist
Knowing what to build is only half the battle. Knowing what to skip is where discipline lives. Here's a checklist of things that almost never belong in an MVP:
Skip: User accounts and profiles (when possible)
Do users need to sign up to get value? If your product can work with a magic link, a shared URL, or even no authentication at all, skip the full auth system for v1.
Basecamp launched in February 2004 without file sharing and without a way to bill customers, according to its founders. They shipped the core project tools first and added the rest once people were paying.
Skip: Admin dashboards and analytics
You don't need a beautiful analytics dashboard when you have 10 users. Check the database directly. Use a simple tool like Metabase or even a spreadsheet. Build the admin dashboard when you have enough users to justify it.
Skip: Notifications and email sequences
A complex notification system with preferences, digest emails, and in-app alerts is a Tier 3 feature at best. For your MVP, a simple email for the most critical event (like "you got paid") is enough.
Skip: Multi-platform support
Don't build a web app and a mobile app simultaneously. Pick the platform where your ICP spends the most time and nail it. The other platform can come when you have product-market fit.
Skip: Performance optimization for scale
Your MVP won't have 100,000 concurrent users. Don't architect for scale on day one. Use simple, proven tools. Optimize when traffic demands it.
Skip: Fancy onboarding
A complex onboarding wizard with tooltips, progress bars, and interactive tutorials is wasted on an MVP. If your product needs a 10-step onboarding to be understood, the product is too complex, not the onboarding.
Skip: Integrations
"But my users need Slack integration!" Maybe. But for v1, a Zapier connection or even a manual workaround is fine. Native integrations are Tier 2-3 features.
Skip: Customization and settings
Fewer options means fewer decisions for the user and fewer edge cases for you. Pick the best default and ship it. Add customization when users specifically request it.
How to build an MVP: a week-by-week roadmap
To build an MVP, spend a week planning, two weeks building only the Tier 1 features, a third week fixing bugs and preparing the launch, then launch in week four and let real usage decide what comes next. The weeks assume a software build; for a concierge or Wizard of Oz MVP, the build weeks shrink to days.
Week 0: Plan before you build
This is the most important week. Before you open your code editor, you need:
- A validated ICP. Who is this for? (Here's how to define yours.)
- A clear core value loop. What's the one outcome your product delivers?
- A feature tier list. What's Tier 1 vs. everything else?
- A launch plan. How will you get your first 10 users?
This is the week a launch route pays off. LaunchMap covers these four points as stages with a measurable gate each: the problem and demand stages confirm the ICP and the core outcome with interviews and a landing page, and only then does the MVP stage turn what you learned into build missions. When the MVP gate is passed, the route moves on to finding the first customers. You walk into week 1 knowing what the product must do and for whom.
Week 1-2: Build the core
Focus exclusively on Tier 1 features. No UI polish. No edge case handling. No "quick wins" from other tiers.
Rules for this phase:
- Use existing tools wherever possible (auth: Supabase/Clerk, payments: Stripe, email: Resend/Postmark).
- Don't build what you can buy or borrow.
- Ship ugly. CSS polish is a Tier 2 task.
- Test with 2-3 friendly users mid-build to catch fundamental UX issues early.
Week 3: Polish and prepare for launch
Spend this week on:
- Fixing bugs from your core build.
- Writing minimal copy (landing page, onboarding text, transactional emails).
- Setting up basic analytics (Plausible, PostHog, or even just server logs).
- Preparing your launch channels (Product Hunt draft, community posts, email to your waitlist).
Week 4: Launch and learn
Ship it. Get it in front of real users. Then:
- Watch what they do (not what they say they'll do).
- Note where they get stuck.
- Track which features they ask for first.
- Measure your core metric (activation, retention, conversion, whatever matters most for your core value loop).
The data from your first 2 weeks of real usage is worth more than 2 months of planning.
Week 5+: Iterate based on evidence
Now you pull from your Tier 2 list, but with a twist: re-prioritize based on actual user behavior, not your original assumptions. The features users ask for most urgently move up. The ones you thought were important but nobody mentions move down.
MVP plan and roadmap template
A minimum viable product template fits on one page: the plan says what you are testing, how you will build it and what result counts as a pass, and the roadmap sorts every feature into now, later or never. Copy it into your notes and fill in the brackets.
The plan:
- Product: [name]
- Customer (ICP): [one sentence]
- Core value loop: [one sentence]
- Riskiest assumption: [the belief that kills the idea if it is wrong]
- Build option: [landing page, pre-order, concierge, Wizard of Oz, no-code app or code build]
- Pass line: [what users must do, how many of them, by which date]
- Budget: [cash and hours]
- First 10 users from: [named communities, lists or contacts]
- Launch target date: [date]
- Decision date: [date to build on, change course or stop]
Tier 1 (must ship before launch):
- Feature A: [description, estimated effort]
- Feature B: [description, estimated effort]
- Feature C: [description, estimated effort]
Tier 2 (first 30 days after launch):
- Feature D
- Feature E
Tier 3 (months 2 to 3, driven by user feedback):
- Feature F
- Feature G
Tier 4 (not now):
- Feature H
- Feature I
Explicitly skipped (and why):
Filled in for a hypothetical invoicing tool for freelancers, the plan looks like this:
| Field | Example |
|---|---|
| Customer (ICP) | Freelance designers who send 5 to 20 invoices a month |
| Core value loop | Create an invoice, send it, see it marked as paid |
| Riskiest assumption | Freelancers will leave their spreadsheet to get paid faster |
| Build option | Wizard of Oz: a simple form, with invoices and reminders sent by hand |
| Pass line | 10 of the first 20 users send a second invoice within 30 days |
| Budget | $100 and 10 hours a week for four weeks |
| First 10 users from | Two design communities and the founder's past clients |
| Decision date | Day 30: automate, change the offer or stop |
The "explicitly skipped" section is as important as the feature list. It's your defense against scope creep. When someone (including yourself at 2 AM) says "we should add X," you check the list. If it's already there with a reason, the conversation is over.
Keep the template next to your code: paste it into the README of the repository or the first page of your notes, and update the tiers every week. If you want the stages around it planned too, you can map your idea for free, and the plans page lists what Pro adds.
Real-world MVP examples that got it right
Sometimes the best way to understand MVP scope is to see what successful products shipped on day one.
Twitter (2006): Post short text updates. Follow people. See a feed. No retweet button, no hashtags, no threads, no photo uploads. The core value loop was "share what you're thinking, right now."
Amazon (1995): An online bookstore. Not a marketplace. Not electronics. Not groceries. Books. Jeff Bezos chose the category with the most SKUs and the least need to see the product in person. Everything else came later.
Buffer (2010): Schedule tweets. That's it. No multi-platform support, no analytics, no team features, no AI suggestions. Joel Gascoigne validated demand with a landing page before writing any code.
Notion (early versions): A simple note-taking tool with blocks. No databases, no API, no templates gallery. The core "blocks" concept was the innovation; everything else was iteration.
The pattern is consistent: successful MVPs do one thing well for a specific audience, then expand based on what users actually need. Our collection of MVP examples adds 24 more first versions, most launched since 2019 and many of them not software, so you can find one close to your own idea.
Common MVP roadmap mistakes
Building for investors, not users. Your MVP doesn't need to impress a VC with a feature-rich demo. It needs to solve one real problem for one real user. Investor features (dashboards, team management, enterprise SSO) are irrelevant until you have product-market fit.
Skipping the plan entirely. "I'll just start coding and figure it out" leads to tangled architecture and wasted sprints. Even 30 minutes with the template above gives you more structure than winging it.
Treating all user feedback equally. Not every request deserves to become a feature. Filter feedback through your ICP. If the request comes from someone who matches your ideal customer profile, it's a signal. If it comes from someone outside your target, it's noise.
Setting an arbitrary launch date without a scope. "We'll launch in 3 months" without a defined feature list means you'll fill those 3 months with whatever comes to mind. Define scope first, then estimate timeline.
Never launching. The biggest MVP mistake isn't building the wrong thing. It's never shipping at all. Set a hard deadline and cut scope to meet it, not the other way around.
From MVP to product-market fit
Your MVP is not the destination. It's the tool that gets you to product-market fit faster.
Product-market fit is when your product delivers so much value to your ICP that growth becomes organic. Users recommend it. Retention is strong. You spend less time convincing people and more time serving them.
The path from MVP to PMF looks like this:
- Launch your MVP with Tier 1 features.
- Measure core metrics (activation rate, Day 7 retention, conversion to paid). The unit economics calculator turns retention and price into what one customer is worth, and our guide to unit economics shows how to read the result for four business models.
- Talk to users weekly. Ask what's working and what's missing.
- Iterate in 1-2 week cycles. Ship one improvement at a time.
- Watch for the signal. When users start saying "I can't imagine going back to how I did this before," you're close.
The MVP roadmap is your compass for this journey. It keeps you building the right things in the right order for the right people.
Conclusion
The best MVPs aren't the ones with the most features. They're the ones with the clearest focus.
Your job as a founder is not to build a complete product. It's to build the smallest thing that proves your idea works, then let real users guide you toward what to build next.
Define your core value loop. Sort features into tiers. Skip everything that doesn't serve your ICP's primary outcome. Set a deadline. Ship.
The market will tell you what's missing. Your users will tell you what to build next. But first, you have to give them something to react to.
Stop planning. Start shipping.
If the product is still a side project, our side project to startup plan covers when it makes sense to go full time, and the guide on writing a business plan with AI covers the document banks and investors ask for.
Frequently asked questions
What features should an MVP include?
Only the features a user needs to complete the core value loop: the one outcome your product promises, from start to finish. For an invoicing tool that means creating an invoice, sending it and marking it as paid. Everything else waits until real users ask for it.
How long should it take to build an MVP?
For most software products, four to eight weeks of focused work is a reasonable target for a first version. If the plan needs six months, the scope is too big or it includes work that a manual process could handle for the first customers.
How much does it cost to build an MVP?
It depends on the option. A waitlist page costs $19 a year with Carrd Pro Standard, a pre-order through Stripe Payment Links costs only the card fee of 2.9% plus 30 cents per US payment, and a no-code app costs nothing to build and about $25 to $50 a month on a paid plan to launch. A concierge or Wizard of Oz MVP costs mostly your time, and a code build mostly developer time.
What is the difference between an MVP and a prototype?
A prototype shows how a product might work and is tested for feedback. An MVP actually delivers the core outcome to real users, even if it is rough, so you can measure whether they use it, come back and pay.
What is a Wizard of Oz MVP?
A Wizard of Oz MVP looks automated to the user, but a person does the work behind the scenes. It tests whether people want the outcome before you spend time building the automation.
Can you build an MVP without coding?
Yes. A concierge MVP delivers the result by hand, a Wizard of Oz MVP puts a simple front end on manual work, and no-code tools such as Softr, Glide and Bubble build working apps without code. Write code once people keep using the manual version and the manual work becomes the bottleneck.
Should an MVP have user accounts?
Only if the product cannot work without them. Many first versions run on a magic link, a shared URL or a simple email login, which saves days of work on passwords, profiles and settings.
How do you know when to move past the MVP?
When users come back without reminders, ask for the next feature and start paying or referring others. Until then, improve the core loop instead of adding features.
Written by the LaunchMap editorial team. We research each guide from primary sources and check every number before it goes live. Sources last checked on November 10, 2026.
Sources (11)
- Business Insider: Reid Hoffman on launching before you feel ready
- 37signals, REWORK podcast: Launch now (how Basecamp launched in 2004)
- CNBC: why Jeff Bezos chose books for Amazon (1997 interview)
- Buffer: idea to paying customers in 7 weeks
- Notion release history (1.0 in 2016, databases in 2.0 in 2018)
- Carrd: Pro plans and prices
- Stripe: pricing and fees (US card rates, Payment Links)
- Softr: plans and pricing
- Bubble: pricing
- Glide: pricing
- FTC: Business guide to the Mail, Internet, or Telephone Order Merchandise Rule
Updated November 10, 2026: added a table of MVP build options by skill, time and cost with tool prices checked on each vendor's pricing page, a copyable MVP plan template with a filled example, and FAQ answers on cost and building without code.