Guide6 min read
How to Scope an MVP: The 7 Steps We Use Before Every Build
In short
To scope an MVP, write down the one job a user must finish, then pick only the parts that job needs, find every system you depend on, and write an 'after launch' list for everything else. This is the process we use before every build, with a one-page scope template you can copy.
Reviewed by Alpit Patel, Founder and CEO · Updated November 14, 2026
Part of the guide: Software development
On this page 11 sections
- How do you scope an MVP?
- Step 1: Write the one job
- Step 2: Name the sides, then build for the fewest
- Step 3: Pick the parts the job needs
- Step 4: Find every outside dependency
- Step 5: Write the after launch list
- Step 6: Decide what success looks like
- Step 7: Agree how changes work
- A one-page MVP scope template
- Mistakes we see most
- How long does it take, and what does it cost?
Key takeaways
- Scope from the job, not from the feature list. If you cannot say in one sentence what the first user must finish, you are not ready to scope.
- Most of the MVPs we have built had about 5 core parts. Which parts you pick matters more than how many.
- Outside systems are what make builds longer. Our builds that depended on one took about a week longer on average.
- The 'after launch' list is the most useful page in the scope. It lets you say no without losing the idea.
- Agree before the build that new ideas either replace something of similar size or wait. That rule is the main reason our timeframes hold.
How do you scope an MVP?
Write down the one job your first user must be able to finish. Then keep only the parts of the product that job needs, find every outside system you depend on, and put everything else on a written “after launch” list. The rest of this guide is how we do each step, and the mistakes we see most.
We scope every build this way before we quote it. GoHangars came to us after two other teams had taken deposits and delivered nothing usable. The founder had a Figma file and a 300-row spreadsheet of hangar operators. We agreed a seven-week scope for a working marketplace with real listings in it, not a prototype, and it shipped in seven weeks.
Step 1: Write the one job
One sentence: who the first user is, and what they must be able to finish.
For example: “An aircraft owner can find a hangar that fits their plane at their airport, and book it.”
That sentence does more scoping work than any feature list. Everything that follows gets tested against it. If you cannot write it yet, you are not ready to scope. You are still deciding what the product is, and that is fine, but it is a different conversation.
Step 2: Name the sides, then build for the fewest
List every type of person who will touch the product: customers, providers, admins, managers, partners. Then ask which ones the job cannot happen without.
For a marketplace that is usually two: the buyer and the supplier. Admin work can often be done by hand for the first months. A founder approving 20 new providers a week from a simple admin screen is fine. Building a full moderation system for them in version one is not.
Step 3: Pick the parts the job needs
Now, and only now, list features. We think in building blocks: payments, booking, search, notifications, verification, a dashboard and so on.
When we coded the features of 43 MVPs we built, a typical one had 5 core blocks. The most common were an operator dashboard, payments, notifications, booking and search. Two things from that study shape how we scope:
- Always include a view for whoever runs the product. More than half of our first versions had one as a headline feature. Someone has to see what is happening on Monday morning.
- If you will charge, charge from day one. Payments added no build time in our data, and money is the clearest proof the product works.
For every feature on the list, ask: can the user finish the job without this? If yes, it moves to the after launch list.
Step 4: Find every outside dependency
List every system the product has to talk to that someone else controls: an airline’s fare system, a lender, a supplier network, an email provider, a booking platform the client already uses.
These are what make builds longer. In our builds, the ones that depended on an outside system took about a week longer on average, because we cannot control its documentation, its test accounts or how fast its team replies. Spirit Airlines’ group booking desk connected to the airline’s fare system and was our longest build at 10 weeks.
For each dependency, write down who owns access and get test credentials before the build starts.
Step 5: Write the after launch list
This is the most useful page in the scope. Every idea that did not make the cut goes here, in writing.
It does two things. It lets the founder say no without feeling they have lost the idea. And after launch, it becomes the starting point for round two, ordered by what real users do.
Some things are left out for good, on purpose. Alendil, a rental marketplace we built, has no fee line items at checkout, and the system has no way to add them. That was a product decision, not an oversight.
Step 6: Decide what success looks like
Pick one or two numbers that will tell you, about a month after launch, whether the product works. Bookings made. Repeat use in week two. Providers who list a second time.
This step also cuts scope. A feature that will not move either number is hard to justify in version one.
Step 7: Agree how changes work
Ideas will come during the build, and some will be good. Our rule: a new feature either replaces something of similar size, or it goes to the next round. Both are fine. What we do not do is quietly add it on top; that is how scope creep starts.
That rule is the main reason our timeframes hold. Changes still happen, and some of them matter. Offline cash logging was not in the original scope for the Coo fundraising platform. We added it because it let volunteer groups move online without changing how they already worked.
A one-page MVP scope template
This is our one-page scope, with two rows we recommend adding: success numbers and platform. Copy it.
| Section | What to write |
|---|---|
| First user | One sentence: who they are and what they are doing today instead |
| The one job | One sentence: what they must be able to finish |
| User types | Every side of the product, and which ones v1 is built for |
| Features | The building blocks the job needs, plus the operator view |
| Outside systems | Each one, who owns access, and when test access arrives |
| After launch list | Everything that did not make the cut |
| Success numbers | One or two, checked a month after launch |
| Change rule | Swap something of similar size, or move it to the next round |
| Platform | Web app, mobile app or both, and why |
On platform: our default is a responsive web app first, adding mobile once usage proves the need. We change that when the product lives on the phone.
Mistakes we see most
- Starting from a competitor’s feature list. Their product is years old. Yours needs to do one job well.
- Building every user type at once. Admins, managers and partners can often wait, with the work done by hand.
- Assuming integrations are quick. Ask for access first. It is one of the most common reasons a build runs longer.
- Treating “minimal” as unfinished. The parts you keep should work properly. A short list built well beats a long one built halfway.
- No written after launch list. Without it, every good idea fights its way into the current build.
How long does it take, and what does it cost?
Scoping is the short part. The build that follows took 5 to 10 weeks across our published builds, with a median of 7. Our app and web app builds typically cost $7,000 to about $25,000-$30,000, quoted fixed-price or hourly, with 30 days of support after launch included, then hourly.
If you want us to scope yours, book a free 30-minute call. Tell us who the first user is and the one job they need to get done. We send back a written scope, a quote and a week-by-week plan. You can also read how we run the whole build on our MVP development page.