An MVP starts with a question you want to test
This guide is for businesses commissioning the first version of a web or mobile application. An MVP, or minimum viable product, helps test an assumption about a user's need and the value of a solution. In Lean Startup, it is part of a cycle of building, measuring and learning.
The rest of this guide focuses on a working application's scope. Before commissioning development, some assumptions can be tested through interviews, a screen prototype or a manually delivered service. If the greatest uncertainty is whether anyone needs the solution at all, a substantial software system may not be the first step.
Once you decide to build, choose a concrete question. For example: can employees report and handle faults in one place without moving data between messages? This provides a better starting point than the broad goal “we need a business app”.
Choose one audience and one primary task
Describe who will use the first version, in what situation and what result they need. Rather than designing for every department immediately, start with a defined group and workflow. Record how that group works today: by phone, spreadsheet, form or another application.
In an illustrative issue-reporting system, the primary task might be passing a fault to the responsible person and checking whether it has been resolved. The reporter and the support employee need different permissions, but they participate in the same journey. There is no need to build separate modules for every possible role in the organisation from the outset.
- audience: who performs the task
- situation: when and on which device they use the app
- problem: what makes the current approach difficult
- outcome: how they recognise that the matter is resolved
Plan a complete journey from beginning to end
A smaller scope should still support a complete process. Users must be able to move from the necessary inputs to a useful result. Saving a report form is insufficient if nobody can subsequently find the issue or update its status.
The example below is a proposed scope for discussion rather than an account of a particular CodaLumo implementation. It exposes dependencies that are often missing from an initial list of screens.
- an employee describes a fault and submits a report
- the application saves the data and confirms submission
- an authorised employee finds the issue and updates its status
- the reporter can see its current state and eventual completion
- both sides receive clear information when an operation fails
Include the capabilities needed to complete that task
Every first-version feature should support the core journey, a condition for safe use or the assumption being tested. User accounts are needed where people and their access must be distinguished. Payments are essential if making a purchase is the task you want to test. There is no universal module checklist for every MVP.
Define the data as well. Agree which fields are required, who can change them, how to correct a mistake and what happens to incomplete records. A simple screen built around clear rules can be more useful than many views without an agreed workflow.
Defer additions that the first test does not need
For each item, ask whether users can still complete the task and whether you can still test the chosen assumption without it. If both answers are yes, consider a later phase. In the issue-reporting example, an advanced management report may wait, whereas a basic issue list belongs to the core workflow.
A manual step can be a reasonable starting point when it is clearly documented, assigned to someone and does not create unacceptable risk. Include its operating effort in your plans. Automating a process without deciding who handles exceptions merely moves the problem elsewhere.
- advanced reports when a basic data view is sufficient
- visual customisation unrelated to completing the task
- additional languages when the pilot serves one language group
- further integrations when the agreed workflow works without them
Agree the foundations for quality, access and maintenance
Before real users receive access, determine what information the app processes and who should see it. Check data storage and retrieval, required fields, error behaviour and the visibility of information for each role. Requirements depend on the product and the risks associated with its use.
Include responsibility for support requests, updates and backups, along with a way to restore data. If the application supports an important workflow, agree what happens during an interruption. Discuss these arrangements before the pilot rather than after the first incident.
Write acceptance criteria and measures of usefulness
An acceptance criterion describes behaviour that can be checked. For example: after a valid submission, the user sees an issue number, and an authorised employee can find it in the list and update its status. Describe failed operations, missing information and access without the required permission separately.
A measure of usefulness answers a different question: does the product help its audience? In the reporting example, you might observe task completion without assistance, handling time or issues requiring an extra phone call. Record a baseline and a collection method before launch. Agree when you will review the results and which decisions they could inform.
Combine measurements with conversations with pilot participants. A failed task could result from the form's wording, notification timing or unclear responsibility rather than a missing feature.
GOV.UK Service Manual — measuring the success of digital services
Give the developer a first-version scope and a decision plan
To request a quote, prepare the goal, audience, task journey, data, essential integrations and acceptance criteria. Separate first-version features from ideas for later. A developer can then explain dependencies and estimate a concrete deliverable.
Also agree what deployment and handover include and how changes after the pilot will be priced. The next phase should follow what you learn from using the product. A long list of future ideas does not create an obligation to build them all.
An MVP scope checklist before development starts
- Can we identify the audience, their problem and one primary task?
- Does the first version let them complete that task from start to finish?
- Does every feature support the workflow, a risk or an assumption to test?
- Have data, permissions and error behaviour been agreed?
- Do we know how to accept the product and assess its usefulness after launch?
- Is someone responsible for the pilot, support and the next-phase decision?