# How to scope an MVP: one user, one job, one decision

URL: https://pixelactstudio.com/blog/how-to-scope-an-mvp

> How to scope an MVP around one user and one job: which features to cut, what must be production-grade, what can stay manual, and how to write exclusions.

By Dev Talan. Published 2026-11-01. Updated 2026-11-01. Type: Guide.

## Key takeaways

- Write the user, the job, and the decision as three sentences at the top of the scope document, then draft the exclusions list before the feature list, with a reason and a fallback for each exclusion.
- Put each feature idea through the cut test in order and stop at the first question that decides it: does the first release need it for the job or the decision, can your team do it by hand at the expected volume, and would a failure lose data, money, or access?
- Even in version one, use a proven auth library with roles checked on the server, Postgres constraints with a restore you have tested, duplicate-safe payment webhooks, and error alerts that reach a named person.
- Run manual steps, such as data imports and invoicing, through a reviewed script, a small admin action, or the payment provider's dashboard. Never edit the production database by hand.
- Fix the date first, then move the cut line until the scope fits. When a milestone slips, move a feature out of it and keep the tests on sign-in, billing, and the core path.

Scoping an MVP means picking one user, one job that user must finish without your help, and one decision the first release should let you make. You build the shortest path through that job, keep sign-in, data, payments, and monitoring production-grade, run what you can by hand, and write down what is excluded.

This guide shows how to scope an MVP for a funded startup about to commit its first real budget to software. It follows one example throughout, a scheduling product for field-service companies, so each step ends in a concrete decision.

## What should an MVP prove?

An MVP should prove one thing to one audience: that a specific user will use the product to finish a specific job, often enough to support a business decision. A scope that tries to prove several things at once usually proves none of them clearly, because each result has several possible causes.

- **One user:** A role at a type of company, specific enough that you could recruit ten of them this month. “Dispatchers at field-service companies with 10 to 50 technicians” is a user. “Small businesses” is not.
- **One job:** The task the user must finish without your help, written as a sentence. For the dispatcher: send every technician tomorrow's schedule before 6pm.
- **One decision:** What you will decide once the release has been in use for a set period, and the signal you will read. For example: if most pilot companies run their daily dispatch in the product for four straight weeks and then agree to pay, commit to the full build. If not, revisit the job or the user before building more.

Write these three as sentences at the top of the scope document. Most later arguments about a feature get settled by pointing at them.

## How do you scope an MVP step by step?

Scoping an MVP is a sequence of cuts, each made against the user, the job, and the decision. Work through these steps in order, ideally with the founder who owns the product and the engineer who will lead the build in the same session.

1. **Write the user, the job, and the decision.** Three sentences, as above. If the founding team cannot agree on them in one session, the product is not ready to scope, and that disagreement is the first thing to resolve.
2. **Map the shortest path through the job.** List every screen, rule, piece of data, and integration the user touches between signing in and finishing the job once. For the dispatcher, that is sign-in, a technician list, tomorrow's job list, a day view to assign jobs, and a way to send each schedule.
3. **Put every other idea through the cut test.** Every other idea goes through the three questions in the next section, whoever suggested it. Most of them end up excluded or manual.
4. **Mark what must be production-grade.** Sign-in, customer data, money, and monitoring get the engineering standard of a product with paying customers, however small the feature set is.
5. **Give every manual step an owner.** Each step you choose to do by hand gets a named person, a written procedure, and the volume at which it gets automated.
6. **Write acceptance criteria.** One plain sentence per feature that says when it is done, for example: a dispatcher can assign 40 jobs to 12 technicians and send every schedule in under 10 minutes.
7. **Fix the date, then fit the scope.** Pick the date that matters and split the scope into milestones that end before it. If the scope does not fit, move the cut line.

## How do you decide which MVP features to cut?

MVP feature prioritization works best as a short test applied to one feature at a time. Ask three questions in order, and stop at the first one that decides it.

1. **Does the job or the decision need it in the first release?** If neither does, it is excluded and goes on the exclusions list with a reason.
2. **Can someone on your team do it by hand at the volume you expect?** If yes, it stays manual for now, with a named owner.
3. **Would a failure here lose data, money, or access?** If yes, it is built to production grade, even if that means building less of everything else. If not, build the simplest version that works.

Frameworks such as MoSCoW and RICE rank features, but a ranking does not say where to stop. Without a fixed constraint, MoSCoW lists fill up with must-haves and RICE scores give an order with no cut line. The cut test works because the job and the decision are the constraint.

**The cut test applied to the dispatcher MVP**

| Feature idea | Needed for the job or the decision? | Version one decision |
| --- | --- | --- |
| Day view to assign jobs to technicians | Yes, for the job | Build |
| Sign-in with dispatcher and admin roles | Yes, for the job | Build, production-grade |
| Send each technician their schedule | Yes, for the job | Build as a text message linking to a mobile web page |
| Native technician mobile app | No, the web page covers it | Exclude |
| Route optimization | No, dispatchers order jobs today | Exclude |
| Import of existing jobs from a spreadsheet | Yes, once per customer | Manual, run by the team with a reviewed script |
| Reporting dashboard | For the decision only | Manual, a saved SQL query reads the success signal |
| Per-seat billing | For the decision, after four weeks | Manual invoices from the payment provider, hosted checkout once self-serve sign-up opens |
| Customer self-booking portal | No | Exclude |

## What features should an MVP have?

An MVP should have the features on the shortest path through the job, plus four foundations built to production grade wherever they appear in the product: authentication, data integrity, payments, and observability. Everything else is a candidate for manual work or the exclusions list.

### What must be production-grade even in version one?

These four areas fail in ways that lose customer data, money, or trust, and they are the hardest to fix once real users depend on them. Keep them small, but build them properly. Payments can start as invoices sent by hand, but from the day money moves through the product, the payment code has to meet this standard.

**Production-grade foundations for a first release**

| Area | What version one needs | Why it can't wait |
| --- | --- | --- |
| Authentication and access | A proven auth library or provider instead of hand-written session code, email verification, password reset, roles checked on the server, and isolation between customer accounts | A permissions bug shows one customer's data to another, and trust is hard to win back |
| Data integrity | Postgres with not-null, foreign key, and unique constraints, migrations in version control, and daily backups with a restore that has been tested | Bad rows written in the first month are still there when you need reporting, billing, or a migration |
| Payments | A hosted checkout from a provider such as Stripe, verified webhook signatures, and duplicate-safe event handling, so nothing is fulfilled or credited twice | Double charges and missing invoices reach customers before they reach you |
| Observability | Error tracking, structured logs with a request ID, an uptime check, and alerts that reach a named person | Without it, the first sign of a broken release is a customer email |

For sign-in, the [OWASP Authentication Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html) covers the details early products most often miss, such as returning the same error for an unknown account and a wrong password, and limiting failed attempts per account. Our [startup security checklist](https://pixelactstudio.com/resources/startup-security-checklist) turns those basics into items you can check before customers or investors ask.

Payments are where data integrity and money meet. Stripe's [webhook documentation](https://docs.stripe.com/webhooks) states that an endpoint might receive the same event more than once, and recommends logging the event IDs you have processed. In Postgres, a primary key on the event ID makes that check part of the database rather than a habit.

```sql
create table processed_payment_events (
  provider_event_id text primary key,
  event_type text not null,
  processed_at timestamptz not null default now()
);

insert into processed_payment_events (provider_event_id, event_type)
values ('evt_example_123', 'checkout.session.completed')
on conflict (provider_event_id) do nothing
returning provider_event_id;
```

The same page notes that one action can occasionally produce two separate events with different IDs. A unique constraint on the thing you fulfill, such as the checkout session ID on the order row, covers that case as well.

### What can stay manual at first?

Anything a person on your team can do reliably at low volume can wait for software. A manual step is a deliberate scope decision, so it needs an owner and a written procedure like any feature.

- **Onboarding and account approval.** The founder creates or approves each pilot account.
- **Data imports.** The team cleans and loads each customer's spreadsheet with a reviewed script, instead of building a self-serve importer.
- **Reporting.** A saved SQL query or a weekly export answers the success-signal question until a dashboard is worth building.
- **Invoicing and billing changes.** Pilot accounts pay by invoices sent from the payment provider, and plan changes, credits, and refunds happen in its dashboard, which keeps a record of each one.
- **Secondary notifications.** Reminders and summaries go out by hand, or not at all.
- **Rare workflows.** Edge cases that come up a few times a month go to a person, with the procedure written down.

> **Manual work must not bypass the foundations.** Doing a task by hand never means editing the production database directly. Manual steps run through a small admin action, a reviewed script, or the provider's dashboard, so constraints, permissions, and logs still apply. Hand edits to live tables are a quick way to lose the data integrity version one was built to keep.

## How do you write an MVP scope document?

An MVP scope document is a short written agreement on what the first release contains, what it leaves out on purpose, and how everyone will know it is done. A few pages is usually enough. The exclusions section matters as much as the feature list, because anything not written down tends to be assumed.

- The user, the job, and the decision, as three sentences
- The success signal and how it is measured, such as a `schedule_sent` event counted per account per week
- Features in scope, each with one acceptance criterion
- Production-grade requirements for authentication, data, payments, and observability, stated specifically
- Manual operations, each with an owner and the volume at which it gets automated
- Exclusions, each with a reason and what happens instead
- Assumptions and dependencies: access, data, third-party APIs, and who makes product decisions
- Milestones with dates, and the rule for deciding change requests

Here is how the exclusions section reads for the dispatcher MVP. A missing feature with a written reason and a fallback reads as a decision, not an oversight.

**Example exclusions for the dispatcher MVP**

| Not in version one | Reason | What happens instead |
| --- | --- | --- |
| Native mobile app | Adoption depends on dispatchers | Technicians open a mobile web page from a text message |
| Route optimization | Not needed to test whether dispatchers switch | Dispatchers order jobs by hand, as they do today |
| SAML single sign-on | Pilot accounts are small teams without an identity provider | Email sign-in, revisited when a prospect requires SSO |
| Integrations with accounting tools | Invoicing is outside the dispatcher's job | Customers keep their current invoicing process |
| Languages other than English | Every pilot account works in English | English only, with interface strings kept out of components for later translation |

Record the bigger technical choices, such as the database, the auth provider, or how customer accounts are separated, as [architecture decision records](https://pixelactstudio.com/blog/architecture-decision-records). When someone asks in month three why the product works a certain way, you can answer with a link to the record.

## How long does an MVP take to build?

An MVP timeline follows from its scope, so any number given before the scope exists is a guess. Work the other way: fix the date that matters, such as a pilot customer's start or a fundraise, and move the cut line until the scope fits with tests and review intact.

Feature count is rarely what moves the date. These usually move it more.

- **More than one user type.** Each added role brings its own screens, permissions, and edge cases.
- **Third-party dependencies.** Thinly documented APIs, partner approvals, payment provider onboarding, and app store review all run on someone else's schedule.
- **Data migration.** Moving a customer's existing records into the product needs cleaning, mapping, and checks.
- **Decision speed.** A build that waits days for feedback on each milestone takes longer than one with a decision owner who answers within a day.
- **Regulated data.** Health, financial, or children's data adds review and controls a general product does not need.

Splitting the scope into milestones, each ending in working software accepted against written criteria, shows early whether the date holds. Shipping behind feature flags with a tested rollback path means a late feature can go live switched off instead of delaying the release. Our guide to [safe releases and rollbacks](https://pixelactstudio.com/blog/safe-releases-and-rollbacks) covers that setup.

> **Keep tests and review when a date slips.** When a date is at risk, remove a feature from the milestone. Don't drop tests on sign-in, billing, and the core path, or skip code review, because those gaps surface after launch, when fixing them costs more and customers notice.

## When should you run a pilot before the MVP?

Run a pilot first when one unknown decides whether the MVP is worth building at all. Typical examples are an integration nobody has tested, an AI feature whose accuracy on your own data is unknown, or a workflow change you are not sure users will accept.

A [pilot sprint](https://pixelactstudio.com/services/pilot-sprints) is a short, fixed-price build, from $4,500 at Pixelact, that answers one such question against pass criteria agreed upfront. AI work at Pixelact always starts with one. Its result feeds straight into the MVP scope, because the unknown becomes either a known requirement or an exclusion. Our comparison of [prototypes, pilots, and MVPs](https://pixelactstudio.com/blog/prototype-vs-pilot-vs-mvp) explains which fits when.

If you already have a prototype built quickly with AI tools or no-code, that was a sensible way to learn fast, and it is good evidence for the scope because it shows which screens users reach for first. Before deciding to keep its code, check it against the [AI-built app risk checklist](https://pixelactstudio.com/resources/ai-built-app-risk-checklist), since the four foundations above are the parts a prototype rarely needed.

## What should you do next?

Write the user, the job, and the decision as three sentences, then draft the exclusions list before the feature list. Run the result through the [MVP readiness checklist](https://pixelactstudio.com/resources/mvp-readiness-checklist) to see which gaps remain before a build starts.

If you want help turning that draft into milestones and a first release, our [product development](https://pixelactstudio.com/services/product-development) service starts with this scoping work and ends with a handover any engineer can pick up.

## Frequently asked questions

### How many features should an MVP have?

Count complete paths instead, because features vary too much in size to count. Version one should let one user finish one job from start to end. For the dispatcher in this guide, that path is sign-in, a technician list, tomorrow's job list, a day view to assign jobs, and a way to send each schedule. Users can't give useful feedback on a flow they can't finish.

### Does an MVP need an admin panel?

Usually a small one. The manual steps in this guide, such as approving pilot accounts and correcting imported records, need admin actions so nobody edits the production database by hand. A handful of actions with role checks and an audit log is enough at first. A full back office can wait until support volume justifies it.

### Who should own the MVP scope document?

One person on the founding team owns the product decisions in it, and the engineering lead owns the acceptance criteria and technical requirements. Changes go through both of them, in writing. When several people can add scope informally, the document stops describing what the team is building within a few weeks.

### Can we skip automated tests to launch faster?

Only for screens off the core path, which can rely on manual checks until they settle. Keep automated tests on sign-up, sign-in, permissions, billing, and the core job path, because any release can break those paths and customers notice first. For the dispatcher MVP, the core path is assigning jobs and sending each schedule.

### What if a key prospect asks for a feature during the build?

Treat it as a change request. Write it down, estimate it, decide what it displaces or how the date moves, and confirm the choice in writing. Sometimes it belongs in version one because it changes the decision you are testing. More often it goes on the exclusions list with a date to revisit it.

### Should an MVP be built for one customer account or many?

If you plan to sell to many companies, design for multiple customer accounts from the start, even if the first release has three. Adding tenant boundaries later means changing tables and queries under live data. Postgres row-level security, or one tested data-access layer, keeps each customer's records separate at modest cost in version one.