An MVP scoping workshop has one job: to turn a product idea into a scope small enough to build, test, and put in production in a fixed time. In the format this article describes, the workshop takes the first three days, and the product goes into production by day 30. Three days is not long, so the workshop has to end with decisions, not with a list of ideas. This article covers what those decisions are, how to cut a scope down to size, and how to write the result as a specification that an AI coding agent can build from.
What an MVP scoping workshop must decide
An MVP tests one idea with real users. Everything the workshop decides follows from that sentence. By the end of the third day, these questions have written answers:
- The goal. Which assumption does the MVP test, and what would users have to do to prove it right or wrong? "Users pay for the second report" is a goal. "Launch the platform" is not.
- The users. Who uses the first version, and who does not yet. One primary user group is usually enough.
- The core flows. The three to five user flows that the test needs, for example sign-up, the main task, and payment. A flow is a path from a user's intent to a result, not a screen.
- The platform. Web or mobile, not both. Building for a second platform doubles much of the work without testing a second idea.
- The integrations. Up to two external systems, for example a payment provider, an identity check, or a partner API. For each one: what it is used for, and whether a test environment is available.
- What waits for a later phase. Certifications such as PCI DSS, licensing work, and large data migrations. If the idea cannot be tested without one of them, it is not a 30-day MVP, and it is better to know that on day three than on day twenty.
- The definition of done. What has to be true on day 30 for the MVP to count as delivered.
- The price. At the end of the workshop the scope is fixed, and so is the price for that scope.
Cutting scope
Most workshops start with too much. Cutting is the main work, and a few rules make it faster.
Cut by flow, not by feature. Write each core flow as a sequence of steps, from the user's first action to the result. Any feature that does not appear in one of those steps is a candidate for the later phase. Admin screens, settings pages, and notification preferences are the usual first cuts.
Ask whether the test fails without it. For each remaining feature, ask: if this were missing, could the MVP still prove or disprove its goal? If the answer is yes, the feature waits.
Do it by hand first. Some steps can be done by a person behind the scenes in the first version: approving an account, sending a report, matching a request. If the step proves valuable, it gets automated in the next phase, with real data on how it is used.
Use an integration instead of building. Payments, identity checks, and email are services, not features to write. Each integration you choose counts toward the limit of two, so pick the ones the goal depends on.
Write down what you cut. Every feature that is cut goes onto a list for the next phase, with the reason. That list is what makes the cuts acceptable: nothing is lost, only scheduled.
Writing a spec an agent can build from
When AI coding agents write much of the code, the specification is what they work from. The behaviour and the acceptance criteria are written down, and each change is checked against them. A vague specification does not slow an agent down. It makes the agent guess, and the guesses look like finished code.
A specification that works for agents and for people has, for each core flow:
- The actor and the trigger. Who starts the flow and how.
- The steps and the rules. What happens at each step, including what the system refuses and why.
- Acceptance criteria. Each one is short, testable, and written in the same form, for example Given, When, Then.
- What is out of scope. The cut list from the workshop, stated next to the flow it affects, so the agent does not add it back.
- The data. The main entities and their fields, as far as the flows need them.
- The integrations. Which external API is called at which step, with which data, and what happens when it fails.
An acceptance criterion in that form:
Given a signed-in user with a confirmed email
When they submit the payment form with a valid card
Then the payment provider is charged once
And the user sees the confirmation screen
And a receipt is sent to their emailEach criterion becomes at least one test. That gives the senior engineer who reviews every change a clear question for each pull request: does this change make the next criterion pass, without breaking the ones that already pass?
Changes after the workshop
A fixed scope does not mean nothing can change. It means changes are decided, not drifted into.
- Weekly demos. Every Friday there is working software to look at. That is the moment to decide what comes next, with the cut list at hand.
- Agree before building. If the scope changes during the build, the change and its cost are agreed before work on it starts.
- Swap rather than add. When something new becomes urgent, the first question is what it replaces. A swap keeps the 30 days realistic; an addition usually does not.
The day 30 definition of done
The workshop should write down what day 30 looks like, so that both sides recognise it when it comes. A useful definition has four parts:
- In production. The product is released and ready for its first users, not running on a demo server.
- The criteria pass. Every acceptance criterion of every core flow is met and covered by tests.
- Handed over. The source code, the repositories, and the intellectual property belong to the client, and the handover is done.
- A plan for the next phase. The cut list, reordered by what the first users showed, becomes the start of the next scope.
The payment terms follow the same milestones: half when the build starts, half at launch.
How we can help
Our MVP development in 30 days starts with this workshop. A principal developer and product builder agrees the scope with you in three days, builds the product with AI agents in the workflow, reviews every change, and puts it into production by day 30, at a fixed price for the agreed scope.
