# MVP readiness checklist: what to settle before you build

URL: https://pixelactstudio.com/resources/mvp-readiness-checklist

> A 44-point MVP readiness checklist for funded founders: problem, scope, data, security basics, team, budget, and launch, plus which gaps to close first.

An MVP readiness checklist tests whether a startup is ready to commit a build budget to version one. You are ready when the first user and their job are named, scope and exclusions are written, data sources are known, security and reliability basics are planned, one person decides, the budget fits, and you know what launch should prove.

This checklist is for founders, CTOs, and heads of product at seed and Series A startups with a funded plan and no version one yet. It applies to an in-house team, freelancers, or a studio alike, because each of them needs the same answers before the first sprint.

Use it as an MVP planning checklist before you ask anyone for a quote, again at kickoff, and whenever the scope changes by more than one feature. It works best when the person who owns the product and the person who will lead the build fill it in together, in one sitting.

- Mark a check yes only when the answer is written down where the whole team can find it.
- Count “mostly”, “we know but haven't written it”, and “the developer will decide” as no.
- Total your yes answers per group, then use the scoring guide at the end to decide what to fix first.

The scope group also works on its own as an MVP scope checklist. It follows the method in our guide on [how to scope an MVP](https://pixelactstudio.com/blog/how-to-scope-an-mvp), which works through one example in detail.

## Do you know the problem and the first user?

- [ ] Name the first user as a role at a type of company, specific enough that you could book calls with ten of them this month. “Small businesses” cannot be recruited, interviewed, or onboarded, so every feature request sounds equally valid. “Dispatchers at field-service companies with 10 to 50 technicians” gives the build someone to test against.
- [ ] Write the one job that user must finish with the product, in one sentence without the word “and”. A job with two halves tends to become two products inside one budget. One sentence, such as “send every technician tomorrow's schedule before 6pm”, gives each later scope argument something to point at.
- [ ] Describe how the user does that job today, including the spreadsheet, tool, or person they rely on. The current workaround is what your product competes with, and it is often where your first data import comes from. If nobody can describe it, the problem may not hurt enough for anyone to switch.
- [ ] Hold problem interviews with at least five people in that role within the last 90 days. Old interviews and founder memory drift toward the solution you already want to build. Recent conversations catch changes in tools, budgets, and who owns the problem before you pay to build the wrong thing.
- [ ] Confirm who pays for the product, and whether that is the same person who uses it. When an ops lead uses the product and a finance lead signs the contract, version one also needs what the buyer checks, such as usage reports, invoices, or admin controls.
- [ ] Check whether an existing tool or a manual service already does the job well enough for now. If an off-the-shelf product covers most of the job, a custom build has to win on the part that matters. Know which part that is before you fund the build, because it is also what version one must do best.

## Is the MVP scope written down, exclusions included?

- [ ] Map the shortest path through the job, screen by screen, from sign-up to the job being done. Everything on that path belongs in version one, and everything off it needs a reason. A feature list without the path hides the gaps between features, such as the email that brings a user back to finish.
- [ ] Write an exclusions list with a reason for each item, agreed by everyone who can add scope. Unwritten exclusions return as surprises halfway through the build. A line such as “no mobile app in version one, field users get a responsive web view” settles the question before it costs money.
- [ ] Write an acceptance criterion for every feature, as a sentence someone outside the team could test. “A dispatcher can reassign a job and the technician sees the change within a minute” can be accepted or rejected. “A good scheduling experience” cannot, so the work behind it never finishes.
- [ ] Decide which steps stay manual at launch, and give each one an owner and a volume at which it gets automated. Account approval, data imports, and invoicing can run by hand for the first customers. Without an owner or a trigger, a manual step grows into someone's full-time job.
- [ ] List the user roles and permissions version one needs, and leave out the rest. Roles are cheap to plan and expensive to add later, because every query and screen depends on them. Many first versions get by with three: customer admin, customer member, and your own support role.
- [ ] Choose the platforms that ship first: a responsive web app, iOS, Android, or a combination. Each native app adds its own builds, store review, and release process. A responsive web app often serves the first customers, with native apps added once users need device features a browser handles poorly, such as background location or reliable offline work.

## Do you know where the data comes from and where it lives?

- [ ] List every system version one reads from or writes to, such as Stripe, HubSpot, Google Workspace, or a customer's ERP. Integrations carry schedule risk you do not control: rate limits, missing sandbox environments, and partner approval steps. Each one named before kickoff is one fewer surprise in the middle of a milestone.
- [ ] Confirm API access for each integration: a sandbox or test account, credentials, and documentation for the endpoints you need. Some providers gate access behind a paid plan, a partner program, or a review. [Google's guide to restricted scope verification](https://developers.google.com/identity/protocols/oauth2/production-readiness/restricted-scope-verification) warns that the process can take several weeks for apps that request wide access to Google user data, and apps that store that data on their servers also need a security assessment.
- [ ] Get a real sample of the data the product must import, with the messy rows left in. Exports from real operations carry merged cells, free-text dates, and duplicate customers. A clean demo file hides the import work, which often decides whether onboarding a customer takes an hour or a week.
- [ ] Sketch the core data model: the main records, how they relate, and which customer account owns each one. The data model is the hardest thing to change once customers are live. If one customer must never see another's records, that boundary belongs in the schema, for example a tenant ID on every row, enforced with row-level security in Postgres.
- [ ] Decide which system is the source of truth for each shared record, such as whether customers live in your app or in the CRM. When two systems both edit the same record, sync jobs can overwrite each other's changes without anyone noticing. One owner per record type, with the other side read-only or synced one way, avoids that.
- [ ] Identify the personal or sensitive data the product will hold, and the rules that come with it. Personal data about people in the UK and EU brings UK GDPR and EU GDPR duties, and health or financial data can add sector rules on top. Knowing this early shapes where you host, how long you keep records, and which vendors need a data processing agreement.

## Are the security and reliability basics in the plan?

- [ ] Use a maintained authentication provider or library, with password reset, email verification, and session expiry in scope. Sign-in is the first thing every user touches and a common target for account takeover. Writing your own token and session handling to save a dependency adds risk to the part of the product that can least afford it.
- [ ] Enforce permissions on the server for every read and write, not only by hiding buttons in the interface. A hidden button stops nobody who calls the API directly. Broken access control holds first place, A01, in the [OWASP Top 10:2025](https://top10.owasp.org/2025/A01_2025-Broken_Access_Control/), which notes that access control only works when it runs in trusted server-side code.
- [ ] If version one takes payments, use a hosted checkout or embedded payment fields so card numbers never reach your servers. [Stripe's integration security guide](https://docs.stripe.com/security/guide) notes that handling card data directly can mean meeting more than 300 PCI DSS security controls. Hosted integrations send card details straight to the provider instead, which shrinks your share of that work.
- [ ] Keep secrets in environment variables or a secrets manager, never in the repository or the frontend bundle. A key committed to Git stays in its history after the file is deleted, so it has to be rotated. Anything bundled into frontend code can be read in a browser. Our [startup security checklist](https://pixelactstudio.com/resources/startup-security-checklist) covers the other basics customers and investors ask about.
- [ ] Plan automated database backups, and test one restore before launch. A backup nobody has restored is a guess. Many managed Postgres services offer point-in-time recovery, but someone still has to confirm a restore works and know how long it takes.
- [ ] Set up error tracking, structured logs, and an uptime check before the first real user signs in. Without them, the first sign of a broken sign-up flow is often a customer email days later. Tools such as Sentry, or logs and traces built on OpenTelemetry, are quick to add at the start and slow to retrofit.
- [ ] Run automated tests in CI on sign-up, the core job, and billing, and require code review before every merge. Those paths lose customers or money when they break. Tests on every pull request let the team ship weekly without clicking through the whole product by hand first.
- [ ] Plan how to undo a bad release, such as a feature flag or a redeploy of the previous version. Early releases go out often, and some will break something. Redeploying the previous version only works if every database migration stays compatible with it, as our guide to [safe releases and rollbacks](https://pixelactstudio.com/blog/safe-releases-and-rollbacks) explains.

## Who decides, who builds, and who maintains it?

- [ ] Name one person who owns product decisions and can accept or reject each milestone. When every approval needs a group, each review cycle can stretch from a day to a week. One owner, with a named stand-in for holidays, keeps feedback moving at the pace the plan assumes.
- [ ] Agree how quickly that person answers questions and reviews demos, for example within two business days. Slow feedback delays a build as surely as slow engineering, but it rarely appears in the plan. A written turnaround makes delays visible as they happen rather than at the deadline.
- [ ] Decide who makes architecture calls and reviews code: a CTO, a fractional CTO, or your build partner's lead. A first engineer working alone makes early architecture choices with nobody to check them. A named reviewer catches a weak choice, such as how customer accounts are separated, while it is still cheap to change.
- [ ] Agree where decisions get written down, including the options you rejected and why. Six months later, nobody remembers why the team picked Postgres over Firestore or one service over several. An [architecture decision record](https://pixelactstudio.com/blog/architecture-decision-records) takes minutes to write and prevents the same debate twice.
- [ ] Create the repository, hosting, and third-party accounts in your company's name, with at least two people on your side as owners. Accounts opened under a contractor's email turn a handover into a negotiation. Owning them from day one means any engineer can pick the product up later.
- [ ] Decide who maintains the product after launch: an in-house hire, the build partner, or both. Bug reports and small requests start the day real users arrive. If nobody owns them, the launch team gets pulled back in at random and the next milestone stalls.

## Do the budget and timeline match the scope?

- [ ] Set a budget range for version one, and know where it comes from: the current round, revenue, or a grant. Without a range, every estimate is a guess and every scope cut feels arbitrary. With one, the team sizes the scope to the money instead of discovering the gap halfway through.
- [ ] Name the date that matters and what happens on it, such as a pilot customer starting or a fundraise. A date tied to an event tells you what to cut when the plan slips. An arbitrary date tends to be defended by skipping tests and review, which costs more after launch than a short slip would have.
- [ ] Hold back part of the budget for what the first weeks of real use reveal. Early users find gaps no scope document predicted, such as a missing export or a confusing onboarding step. A budget spent to zero on launch day leaves those gaps open while you raise or hire.
- [ ] List running costs with an estimated monthly figure: hosting, email, error tracking, paid APIs, and app store fees. These bills start before revenue does, and the cost of usage-priced APIs, such as LLM APIs, grows with every active user. Seeing them in the plan avoids a surprise in the first month after launch.
- [ ] Split the build into milestones, each ending in working software you can accept or reject. Milestones turn one large commitment into several smaller ones and show progress you can click through, not a percentage in a status report. Each one is also a clean point to change direction.
- [ ] Agree how scope changes are handled: who asks, who prices the change, and who approves it. Version one will change once people use it. A written change process keeps each change visible and priced before work starts, instead of absorbed into the original estimate.

## Do you know what launch should prove?

- [ ] Write the decision version one should let you make, and the result that would change your plan. A decision written before the build gives the MVP an end point. “If six of ten pilot companies run daily dispatch in the product for four weeks, we fund the next phase” sets both the target and the stop rule.
- [ ] Pick two or three metrics tied to the job, such as activation, task completion, or weekly active accounts, with a target for each. Sign-ups and page views say little about whether the job got done. A target written before launch stops the team from reading any result as a success.
- [ ] Name the analytics events for each step of the core path before the build starts, and decide how analytics will handle cookie consent. Events added after launch miss the first users, who teach you the most. Events such as `job_assigned` and `schedule_sent`, tracked in a tool like PostHog, show where people drop out. In the UK and EU, analytics that store cookies or similar identifiers can need consent first, so choose between a consent banner and a cookieless setup early.
- [ ] Line up the first users before launch, with a name and a start date for each account. A launch with nobody committed produces no signal for weeks. A handful of named pilot accounts gives the metrics something to measure from the first day.
- [ ] Decide how users report problems and who answers, such as a support inbox someone checks every working day. Early users forgive bugs they can report and see fixed. They leave quietly when reports go nowhere, taking the feedback the MVP was built to collect with them.
- [ ] Set a review date, such as six weeks after launch, when the team reads the metrics and makes the decision. Without a date, the MVP drifts into a permanent beta. A fixed review turns the results into a choice: commit to the next phase, change direction, or stop.

## How do you read your MVP readiness checklist score?

Read the score group by group, not as one total. Several gaps in one group usually trace back to one missing owner or decision, so settling that one thing often closes most of them.

**What each result means**

| Result | What it means | Next step |
| --- | --- | --- |
| Two or more gaps in problem and user | The build has no fixed target yet | Hold more user conversations, or test the riskiest assumption with a clickable prototype |
| Gaps in scope, or in budget and timeline | Estimates will move as the scope does | Write the exclusions and acceptance criteria, then ask for quotes |
| Gaps in data and integrations | Schedule risk sits outside your control | Prove the riskiest integration on its own before the full build |
| Gaps in the basics, or in team and decisions | Cheap to fix in the plan, costly after launch | Close them before kickoff |
| Gaps only in launch and measurement | Ready to build | Close them during the first milestone |

### Which failures are urgent?

- **No named first user or job.** Nothing else on the checklist can be judged without them.
- **No single decision owner.** Every milestone waits on a group.
- **Accounts in someone else's name.** Handover becomes a negotiation.
- **Permissions checked only in the interface.** Anyone who calls the API directly can read or change another customer's data.

### When does an outside review make sense?

Bring in an outside review when most gaps sit in data and integrations or the basics, and nobody on your team has built that part before. A fixed-price [pilot sprint](https://pixelactstudio.com/services/pilot-sprints) can prove one risky integration or workflow before you commit to more, and a [software audit](https://pixelactstudio.com/services/software-audits) reviews your plan, or any code that already exists, and ranks the risks to fix first. When the plan passes, our [product development](https://pixelactstudio.com/services/product-development) service builds version one milestone by milestone, starting with a 45-minute discovery call.

## Frequently asked questions

### Is an MVP readiness checklist the same as an MVP launch checklist?

No. An MVP readiness checklist is used before the build starts, to test whether the problem, scope, data, team, and budget are clear enough to commit money. A launch checklist is used at the end, to test whether the finished product is safe to release. The basics and measurement groups here overlap with a launch checklist, because those items cost less to plan before the first line of code than to add at the end.

### How many checks do we need to pass before we start building?

There is no pass mark, because the checks do not carry equal weight. A team at 40 of 44 is not ready if its four gaps are the first user, the decision owner, account ownership, and server-side permissions. A team whose only gaps are in launch and measurement can usually start and close them during the first milestone. Read the result by group, urgent gaps first.

### Do we need a technical cofounder before we build an MVP?

Not necessarily, but someone must own architecture decisions and code review from the first week. That can be a technical cofounder, a fractional CTO, or a named lead at your build partner. A useful test: that person can explain the data model, the hosting setup, and how a bad release gets rolled back in plain words, and writes those choices down so the next engineer can pick them up.

### We already have a prototype built with AI tools. Does this checklist still apply?

Yes. A prototype built with AI tools is a fast way to learn, and if people have used it, it probably answers several checks in the problem and scope groups already. Look hardest at the data and basics groups: permissions, secrets, backups, and tests are what turn a working prototype into a product customers can rely on. The [AI-built app risk checklist](https://pixelactstudio.com/resources/ai-built-app-risk-checklist) goes deeper on that step.

### Can Pixelact help us close the gaps this checklist finds?

Yes. A 45-minute discovery call, with no slides, works through where you stand and what a sensible next step could be. If one question decides whether the product can work at all, a pilot sprint from $4,500 answers it for a fixed price. Our comparison of [prototypes, pilots, and MVPs](https://pixelactstudio.com/blog/prototype-vs-pilot-vs-mvp) explains which fits. When the plan is ready, product development is priced by milestone, and you can [start a project](https://pixelactstudio.com/start-a-project) from the site.