What Belongs in Your
First Product Release?
Scope your first release around one user task, sort every request into now, later or never, and agree how you will know the release is done before the build starts.
Knowing how to scope an MVP is mostly knowing what to leave out. A first release earns its place when a real user can finish one important task with it, and when it protects that user, their data and your money while they do. Everything else can wait until real use tells you what to build next.
The short answer: build one complete user task, plus the controls that must work from the first day: permissions, safeguards against misuse and, if you charge for the product, plan limits. Sort every other request into later or never, write acceptance criteria for the task and each control, and fix the release window before you debate features.
How to scope an MVP: start from one user task
A feature list grows every time someone reads it. A task has a person, a starting point and a result, which makes it much harder to pad. Write it the way the GOV.UK Service Manual recommends for user stories: who the user is, what they need to do and why. The guidance treats the goal as the most important part, because it tells you when the need has been met (GOV.UK, Writing user stories).
Choose a task that is narrow enough to finish within the release window and complete enough to be useful. A user should be able to start it, reach a result and leave without someone from your team stepping in. If the result depends on a manual step behind the scenes, write that step down: it is part of the release, even if it stays manual for now.
Then map the path from start to result. Note who acts at each step (a user, an admin, an approver) and which outside systems are involved. This map frames every later scope conversation, because a requested feature either sits on the path or it does not. Careful product design at this stage keeps the path short, and a shorter path means less to build and test.
Now, later, never: how should you sort MVP features?
Fix the release window before you sort. Nielsen Norman Group's guide to prioritization methods warns that without a clearly scoped timeline, teams risk overloading the "must have" group (Nielsen Norman Group). A fixed window turns "should we add this?" into "what moves out if we do?".
Deciding what to include in an MVP is easier one request at a time. Put every request on its own card and run it through the questions below.
Show the path to
A requested feature
Does the user need it to complete the core task?
Yes
Now
The core task cannot be completed without it.
No
Could leaving it out harm users, expose data or cost money on the first day?
Yes
Now, as a control
Permissions, safeguards, plan limits.
No
Will it be worth building once a clear trigger appears?
Such as repeated requests from early users or a new type of customer.
Yes
Later
With that trigger written down.
No
Never, for this product direction
Record the reason, so the same debate does not return.
Take four requests for a booking product. Choosing a time slot goes into now, because booking is the core task. Making sure customers see only their own bookings goes into now, as a control, because bookings hold their personal details. Exporting bookings to a spreadsheet goes into later, with repeated requests from early users as its trigger. A marketplace for third-party add-ons goes into never, with the reason written next to it: this product direction does not include one.
The later list is a plan with conditions. Each item keeps the trigger that would bring it forward, such as repeated requests from early users, a support question that keeps returning or a new type of customer. Items become candidates for the next release when their trigger appears, and nobody has to argue for them from memory.
Some work never arrives as a request but still belongs in now: the records your team needs to support the core task, and the tracking behind your first measures.
What did a two-month MVP actually contain?
The AI agent platform MVP case study shows a first release scoped against a fixed window. A startup needed a cloud platform where AI agents work as a team, ready to show investors and early users within two months.
The core task was clear: a subscriber sets up an agent from plain instructions or a recommended preset, picks its model, switches on the integrations the agent may use and runs work through a coordinator that splits tasks and hands them between agents that share one memory. The product was built for three groups: team admins (plans, limits, integrations), builders (agents, presets, instructions) and operators (runs, approvals, logs).

2 months from brief to working MVP
Month 1
Agents and memory
- Agent builder
- Coordinator and hand-offs
- Shared memory with a cleaning step before writes
Month 2
Guardrails, models, billing
- Guardrail layer
- Model router: hosted and open-source models
- Stripe subscriptions with agent and token limits
Built in the release window: the core task and its controls
Since delivery
What came next
- The startup raised $3M in funding
Two decisions stand out. Integrations went through standards: compatible systems connect through MCP or REST, with configuration, authentication, mapping or an adapter where needed. And the controls were built within the same two months as the features, because the product was headed for early users as well as investors.
Which controls can't wait for a later release?
Some items look like extras on a feature list but are conditions for letting anyone in. A control belongs in the first release when its absence could harm a user, expose data or cost money on the first day of real use. Check these three before the build starts.
Permissions.
Decide which roles exist, what each role can see and change, and which actions need someone's approval. Adding permission checks after real data exists can mean reviewing every screen and query that touches that data.
Safeguards against misuse.
In AI products, this starts with treating fetched content as data. OWASP puts prompt injection first in its Top 10 for LLM applications, including indirect injection hidden in websites or files, and recommends least privilege and human approval for privileged actions (OWASP). In the agent platform, text from the web or email is checked for embedded instructions, tool permissions define the calls available to each agent, sensitive actions wait for a person's approval, and code runs in a sandbox. OWASP notes it is unclear whether prompt injection can be fully prevented, so these controls work in layers.
Plan limits.
If customers pay for a plan, the product has to enforce what the plan includes. Microsoft's guidance on pricing models for multitenant solutions notes that a flat-rate plan without per-tenant usage limits can become unprofitable, and advises telling customers about limits before they become necessary (Microsoft Learn). The agent platform's subscriptions come with 5, 10 or 20 agents and a token allowance, and enterprise customers get custom limits. The platform uses those limits to help control usage and spending.
In a subscription product, these controls are where tenancy and billing design begins. We cover the deeper version of that work under SaaS development.
Acceptance: how will you know the release is done?
Write acceptance criteria for the core task and for each control before the build starts. The GOV.UK Service Manual describes them as a short checklist of outcomes, often phrased "it's done when…" (GOV.UK, Writing user stories). For a first release, a useful set looks like this:
- It's done when a new user completes the core task without help from your team.
- It's done when a user cannot see or change data they have no permission for.
- It's done when the misuse cases agreed for the release are blocked or wait for a person's approval.
- It's done when an account at its plan limit cannot go past it and is told why.
- It's done when a failure in a connected system leaves a record that shows a person what failed and where.
- It's done when the people supporting the product can trace what happened to a given request.
Agree who signs off each criterion, and test with data that looks like the real thing. Criteria written this way also settle scope changes: a new idea either changes a criterion, and is weighed against the window, or goes into later or never. In our projects, the agreed requirements are what the product is checked against before delivery; how we work describes the milestones and reviews around that.
What drives MVP timeline and cost?
The number of features is only part of it. These drivers usually decide how long a first release takes:
| Driver | Why it adds time | How to keep it in check |
|---|---|---|
| User roles | Each role needs its own screens, permissions and tests. | Start with the roles the core task needs. |
| Integrations | Each outside system needs access, somewhere safe to test, and handling for usage limits and failures. | Connect only the systems on the task's path, through standard interfaces where they exist. |
| Existing data | Imports need rules for duplicates, gaps and ownership. | Agree which data the first release needs and who owns its quality. |
| Controls | Permissions, safeguards and limits need design and testing like any feature. | Keep them, scoped to the core task. |
| Platforms | Each extra platform repeats design, build and testing work. | Start where the core task happens most often. |
| Open decisions | Work waits while questions wait for an answer. | Name one person who can decide scope questions quickly. |
User roles
Why it adds time
Each role needs its own screens, permissions and tests.
How to keep it in check
Start with the roles the core task needs.
Integrations
Why it adds time
Each outside system needs access, somewhere safe to test, and handling for usage limits and failures.
How to keep it in check
Connect only the systems on the task's path, through standard interfaces where they exist.
Existing data
Why it adds time
Imports need rules for duplicates, gaps and ownership.
How to keep it in check
Agree which data the first release needs and who owns its quality.
Controls
Why it adds time
Permissions, safeguards and limits need design and testing like any feature.
How to keep it in check
Keep them, scoped to the core task.
Platforms
Why it adds time
Each extra platform repeats design, build and testing work.
How to keep it in check
Start where the core task happens most often.
Open decisions
Why it adds time
Work waits while questions wait for an answer.
How to keep it in check
Name one person who can decide scope questions quickly.
The same drivers shape the budget, which is why we agree a fixed price only for a clear scope. Our MVP development services start with this exercise: the task, the drivers and a written scope that says what is in, what waits and why.
After release: what should you measure first?
Choose the first measures when you scope the release, and refine them as you build. The GOV.UK Service Manual advises working them out as the service is built, and choosing three or four metrics that answer whether the service is working (GOV.UK, Setting performance metrics). For a first release, start with:
- Task completion: Completed attempts at the core task as a share of all attempts started, which GOV.UK calls the completion rate (GOV.UK, Measuring completion rate).
- Drop-off points: The step where unfinished attempts stop.
- Help requests: What users ask your team, and at which step.
- Usage against limits: For paid plans, which accounts approach their limits and how often.
Release to a small group first. In a private beta, as the GOV.UK Service Manual describes it, a limited number of people are invited so the team can gather feedback and improve the service before opening it up (GOV.UK, How the beta phase works). Watch that feedback for the triggers on your later list.
A one-page MVP scope worksheet
Use one page as your MVP scope document. If the now list does not fit on it, the task is probably too broad for one release. Fill it in before anyone estimates the build, and update it whenever the window, a criterion or a measure changes.
- User and task: Who the first users are and the one task they need to finish.
- Path: The steps from start to result, with the role acting at each step.
- Now: Features the task cannot be completed without, plus the records your team needs to support it and the tracking behind your first measures.
- Controls: Permissions, safeguards and plan limits needed from the first day.
- Later: Each deferred item with the trigger that would bring it forward.
- Never: Rejected items with the reason.
- Acceptance criteria: "it's done when…" statements for the task and each control.
- Systems and data: Integrations on the path, data to import and who owns it.
- Window and decisions: The release window and the person who decides scope questions.
- First measures: Three or four measures you will check after release.
Sources
- GOV.UK Service Manual — Writing user stories
- Nielsen Norman Group — 5 Prioritization Methods in UX Roadmapping
- OWASP Gen AI Security Project — LLM01:2025 Prompt Injection
- Microsoft Azure Architecture Center — Pricing models for a multitenant solution
- GOV.UK Service Manual — How to set performance metrics for your service
- GOV.UK Service Manual — Measuring completion rate
- GOV.UK Service Manual — How the beta phase works
Frequently asked questions
Include the admin tasks the core task depends on, such as inviting users, assigning roles and managing a plan. Reports, bulk tools and settings that nobody needs in the first weeks can go on the later list with a trigger.
Run the request through the same three questions. If it goes into now, decide what moves out of the window, or agree a new window. In our projects, you approve the cost of any additional work before it starts.
Scope it for the users. A demo can satisfy an investor meeting, but a release that real people will use needs the core task and its controls working on real data. The agent platform's controls were part of its first version, because it was intended for early users as well as investors.
Not sure what to leave out of your first release?
Tell us who your first users are and the task they need to finish. We can help you sort the feature list, agree acceptance criteria and plan a first release with the controls it needs.
