How to Define an MVP Without Removing What Users Actually Need
Define an MVP by cutting breadth, not steps. Choose one type of user and one job they need to get done, map every step from start to finish, and keep a simple version of each step – even if some steps are handled manually behind the scenes at first. What you remove are extra features, options, user types and automation. What you keep is every step without which the user cannot finish the job, plus the basics of security, privacy and accessibility. A small but complete first version teaches you something; a version with a missing step mostly teaches you that people gave up.
What "minimum viable" actually means
Eric Ries, who popularised the term, defined the minimum viable product as "that version of a new product which allows a team to collect the maximum amount of validated learning about customers with the least effort". In the same text he warns that "MVP, despite the name, is not about creating minimal products".
The point of an MVP is learning: do people use it, and do they get the result they came for? A version that leaves out a step users need answers neither question, because people stop before they reach the result. "Minimum" refers to effort and scope; "viable" means a real user can complete the job.
The common mistake: cutting a step
Flat feature lists encourage cutting the wrong things. Next to "dashboard" and "reports", items such as "password reset" or "order confirmation email" look small and optional. In practice they hold the journey together. Typical examples:
- a booking system with no way to cancel or change a booking, so every change becomes a phone call;
- a customer portal without password reset;
- an online shop where the order goes through but the customer receives no confirmation;
- an admin panel where data can be entered but not corrected or exported;
- an app that demands an account before showing anything useful.
Jeff Patton, who popularised user story mapping, describes the first release as "the smallest possible system you could build that would give you end to end functionality". He builds all major features a little at a time, so that "we never release a car without brakes".
Step 1: One user, one job
Write one sentence: "[type of user] needs to [do something] so that [result]". For example: "A returning business customer needs to reorder the same products without calling the sales team." If you cannot choose one user and one job, the first version will try to serve everyone and serve no one well. Other users and jobs come in later versions.
Step 2: Map the journey from start to finish
List every step in order, including the dull ones: finding the service, signing up or logging in, doing the main task, paying or confirming, receiving a confirmation, coming back later, fixing a mistake and getting help. This sequence is the backbone of the product. Patton's advice is not to prioritise the backbone itself – every step must exist – but to decide how much depth each step gets.
Step 3: Choose the simplest version of each step
For each step, ask what the simplest version is that still lets the user move on:
| Step | Full version | Simplest version that still works |
|---|---|---|
| Payment | Cards, instalments, saved payment details | Bank transfer or cash on delivery with a proforma invoice |
| Notifications | Email, SMS and push, with preferences | One email at each moment that matters |
| Reports | Interactive dashboards | Export to Excel |
| Support | Live chat and a help centre | A contact form linked to the user's account |
| Admin | Settings for everything | Editing of daily data; rare settings changed by the developer |
| Platforms | Native Android and iOS apps | A web application that works well on phones |
| Languages | Every target market | The language of the first market |
Manual work behind the scenes is acceptable at first, as long as the user's side is complete. If a staff member approves each new account by hand in the first months, the user still gets an account.
Step 4: Prioritise with strict tests
The MoSCoW method, promoted by the Agile Business Consortium, sorts requirements into Must have, Should have, Could have and Won't have this time. Its tests for a Must have are usefully strict: "No point in delivering on target date without this", "Not legal without it", "Unsafe without it", "Cannot deliver a viable solution without it". The consortium also recommends "typically no more than 60% Must Have effort", which leaves room for surprises without dropping anything essential.
Apply the tests to the steps on your map. A step the user cannot finish without is a Must; a nicer version of that step is a Should or a Could. Write the Won't haves down too – an explicit list stops the same debate returning every week.
What not to remove
- Legal requirements. Privacy information, consent where it is required and correct handling of personal data pass the "not legal without it" test.
- Security basics. Proper login, password reset, access control so that users see only their own data, and a protected admin area.
- Accessibility basics. Readable text, sufficient contrast and forms that work with a keyboard and screen readers. W3C notes that accessibility "often improves the online experience for all users". See our accessibility checks for forms and navigation.
- Backups and data export. Losing early users' data costs more trust than launching a little later.
- A way to correct mistakes. Users make errors, and staff need to fix data without calling a developer.
- A way to learn. Simple analytics or logs of what users do, and a way for them to report problems. Without these the MVP cannot do its job.
Step 5: Decide what the first version must teach you
Before development starts, write down two or three questions the first version should answer and how you will recognise the answer. For example: "Do returning customers reorder online instead of calling?", answered by the share of reorders placed online. A feature that neither helps answer such a question nor helps the user finish the job can probably wait.
Test early with real users. Jakob Nielsen of Nielsen Norman Group recommends "testing no more than 5 users and running as many small tests as you can afford". Five people trying to complete the job on a prototype will reveal a missing step faster than any meeting.
Signs the MVP is defined wrongly
- Too thin: you cannot describe a user completing the job from start to finish, several steps are marked "later", and staff will have to handle every exception by phone.
- Too thick: several user types, languages and platforms at once, nobody can say what the first version should prove, and the Must list is most of the project.
This is how we suggest approaching the first version of any web-based software: start from the journey, agree on the simplest version of each step, and make sure that cutting the budget never means cutting a step the user needs. A clear brief helps – see how to write a brief for comparable quotes. If you have an idea and a feature list, send it to us and we will help you find the smallest version that still works.
Sources
- Minimum Viable Product: a guide – Eric Ries, Startup Lessons Learned
- The New User Story Backlog is a Map – Jeff Patton & Associates
- What is MoSCoW Prioritization? – Agile Business Consortium
- Why You Only Need to Test with 5 Users – Nielsen Norman Group
- The Business Case for Digital Accessibility – W3C Web Accessibility Initiative