Wall & Fifth

MVP Development Checklist: Confirm Before a Build Starts

The decisions that are cheap before a build and expensive mid-project. Scope, ownership, billing, hosting and post-launch — confirmed in writing.

By William · Updated 1 November 2026 · 10 min read

The brief you hand a studio is less important than the decisions you make before you hand it over. Scope, ownership, billing structure, hosting control, and post-launch responsibility all need to be settled in writing before work begins — not discovered partway through. This checklist works through each area in order, from problem definition to handover, so you arrive at your first studio conversation with the right questions already formed.

Why the pre-build checklist matters more than the brief itself

A brief describes what you want. A checklist confirms that both sides understand what they are committing to. The decisions in this guide are cheap to make during a scoping conversation and expensive to unpick once development is under way. Changing a billing model mid-project, discovering that you do not own the hosting account, or realising the scope never defined a second user type — each of these is a genuine crisis at week five and a five-minute conversation at week zero.

Eric Ries defined an MVP as the version of a new product that allows a team to collect the maximum amount of validated learning about customers with the least effort. [1] That framing is instructive: the goal is learning, not completeness. A checklist that protects your scope protects the learning signal too — because an over-built, over-budget product that shipped late tells you almost nothing useful about what users actually need.

CB Insights analysed public post-mortems and shutdown announcements from VC-backed companies that shut down since 2023. Among the 385 companies for which failure reasons could be identified, poor product-market fit was cited by 43% as a primary cause of failure. [3] The checklist below is designed to keep the build small enough and focused enough that you get a genuine signal before you run out of runway.

For context on how to evaluate the studio you are about to brief, the guide on choosing an MVP development company in the UK covers what separates a credible studio from a template shop or offshore hourly team.

Scope: define one core job before anything else

Scope is where most MVPs quietly become expensive. The moment a second user type, an admin panel, or a notification system enters the conversation without a corresponding removal from the list, your timeline and budget are already moving.

The one-sentence test

Write a single sentence that describes what your MVP does for its primary user. If the sentence contains two verbs — users can book and manage — you are probably describing two products. Reduce it until there is one action, one user, and one outcome. That sentence should govern every scoping decision that follows.

Scope checklist

  • One core user type confirmed. If there is a second user type — for example, both buyers and sellers — decide whether they are both in scope for version one or whether one side ships first.
  • Core journey mapped. The path a user takes from arriving to completing the main action should be written out step by step before design begins.
  • Out-of-scope list agreed in writing. Every feature that is not in version one should appear on a named list, agreed by both sides. This prevents them drifting back in under a different name mid-build.
  • Success condition defined. What does the MVP need to prove? Write it down. If you cannot state a clear hypothesis, the build has no way to succeed or fail on its own terms.

If you are building at pre-seed, the guide on how MVP priorities shift at each funding stage is worth reading before you finalise your scope — the right first version looks different depending on where you are in your funding journey.

Commercial terms: what to nail down before signing

Commercial misunderstandings are the most common source of founder-studio conflict. None of these conversations are difficult to have before a contract is signed. All of them are difficult after work has started.

Billing model

Model What it means in practice Who carries the overrun risk
Fixed price You know the total before work starts. Scope must be defined first. The studio
Hourly or time-and-materials You pay for hours logged. Final cost is unknown at the start. You
Capped time-and-materials Hourly billing with an agreed ceiling. Often hits the ceiling. Shared, in practice usually you

A fixed price only works when scope is properly defined. A studio offering fixed pricing without a scoping phase is not fixing the price — it is guessing it. The scoping conversation is the work that makes a fixed price meaningful.

Commercial checklist

  • Billing model confirmed in writing — fixed price, hourly, or capped.
  • Scope change process agreed. What happens if a new feature is added? Is there a change request process? Is the price adjusted? Who approves it?
  • Code ownership clause present. The contract should state explicitly that you own the codebase produced for your project. If reusable components are used, the proposal should identify them and clarify the licence terms.
  • Payment milestones defined. Know when payments fall due and what is delivered at each stage.
  • Termination terms understood. If the relationship ends early, what do you receive and what do you owe?

Technical decisions: hosting, stack, and account control

The technical decisions made before a build starts determine what you can do after it ends. A product built on a proprietary platform you do not own, hosted on accounts controlled by the studio, using a stack no other developer can work in, is not yours in any practical sense — regardless of what the contract says.

Technical checklist

  • Stack documented and hireable. Ask for the specific technologies. A mainstream stack — such as React, Next.js, TypeScript, and PostgreSQL — means any competent developer can work on it after you. A proprietary or unusual stack locks you to your current studio.
  • Hosting accounts owned by you. Your domain registrar account, cloud hosting account, and database should be registered to you or your company, not to the studio. The studio may deploy on your behalf, but the account credentials should be yours from day one.
  • Third-party service accounts in your name. Stripe, authentication providers, email services, and analytics platforms should be set up under your own account and connected to the build — not the studio's account with an API key shared as a favour.
  • Database and data portability confirmed. You should be able to export your own data at any time. Ask how.
  • No proprietary tooling dependency. If the build requires a tool, platform, or plugin that is exclusive to the studio, understand what that means when the engagement ends.

Hypothetical example: A founder builds a SaaS product with a studio that deploys everything to the studio's own cloud account. Six months after launch, the studio winds down. The founder has the code repository but cannot access the running environment, the database, or the connected services. The product is live but effectively inaccessible until someone migrates it — an expensive and time-consuming task that was entirely avoidable.

Design and delivery: sign-off, feedback, and expectations

Design is where most of the structural thinking happens in a well-run build. A studio that skips directly to code is skipping the stage that prevents expensive rework. Equally, a founder who is unavailable during design reviews or who provides feedback after a long delay is one of the most reliable ways to push a project over time.

Design and delivery checklist

  • Design review points agreed. Know when you will see the product design, what format it will be in, and how many rounds of feedback are included.
  • Sign-off authority named. One person on your side should have authority to approve designs and decisions. Multiple approvers with different opinions will slow every stage and introduce contradictions into the brief.
  • Feedback turnaround time agreed. Studios typically need a response within a defined window to keep a project on schedule. Know what is expected of you and whether you can meet it.
  • Update cadence confirmed. How often will you hear from the studio during development? Weekly updates, a shared project board, or a dedicated communication channel — know which and use it.
  • What happens if scope needs to change mid-build. The answer should be a documented change request process, not an informal conversation that quietly expands the scope.

Post-launch: maintenance, monitoring, and handover

The end of a build is not the end of the product's needs. Software requires dependency updates, monitoring, and responses to user-reported issues. If you have not agreed who handles this before launch, you will be negotiating it under pressure when something breaks.

Post-launch checklist

  • Maintenance arrangement confirmed. Is there an ongoing retainer for fixes and updates? Is post-launch support included for a defined period? Is it pay-as-you-go? Know before you launch.
  • Monitoring in place. Error tracking, uptime monitoring, and alerting should be configured before launch, not added later. Ask who receives the alerts and who responds.
  • Handover documentation agreed. At the end of the engagement you should receive documentation that covers the architecture, the deployment process, the environment variables, and any third-party integrations. A codebase without documentation is a partial handover.
  • App store submission included (if mobile). If you are building a mobile app, confirm whether the studio handles App Store and Google Play submission as part of the project, or whether that falls to you.
  • Credentials and access transferred. All accounts, API keys, and admin access should be formally transferred at handover, not left in a shared document that expires.

A one-page checklist summary

Before briefing a studio, confirm each of the following:

Area What to confirm
Scope One-sentence core promise; out-of-scope list in writing; success condition defined
User types All user types named; version one coverage confirmed
Billing Fixed price or hourly; scope change process; payment milestones
Ownership Code ownership clause; reusable component licences identified
Stack Technologies documented; hireable by another developer
Accounts Hosting, domain, Stripe, analytics — all in your name
Design Review points agreed; sign-off authority named; feedback window confirmed
Post-launch Maintenance arrangement; monitoring configured; handover documentation included

Frequently asked questions

Do I need a technical co-founder before briefing a studio?

No. A studio that requires you to have a technical co-founder in place is, in effect, asking you to do their job for them. You should be able to arrive with a clear problem, a target user, and a sense of the core journey — the studio should handle the architecture, stack decisions, and technical delivery. That said, having someone technical available to review the proposed stack and contract terms before signing is genuinely useful, even if they are a trusted adviser rather than a co-founder.

What if the studio refuses to put the out-of-scope list in writing?

Treat this as a significant warning sign. An out-of-scope list is not adversarial — it protects both sides by making the boundary explicit. A studio that declines to document what is not included is leaving itself room to underdeliver and you with no clear recourse. This is one of the red flags covered in detail in the guide on how to evaluate UK MVP development companies.

What does code ownership actually mean in practice?

It means that when the engagement ends, you have a codebase in a repository registered to you, with no obligation to keep paying the studio to access or run it. Some studios use reusable internal components or third-party frameworks — these do not change hands, and nor should they. What matters is that the custom code written for your project belongs to you, and that the contract states this clearly. Any retained IP or shared component licences should be disclosed in the proposal before work starts.

How much should I expect to spend on post-launch maintenance?

This depends entirely on the complexity of the product and the level of cover you need. A simple web app with stable third-party integrations needs less active maintenance than a platform with multiple user types, custom billing logic, and frequent third-party dependency updates. The important thing is not the number — it is having an arrangement in place before launch so that the responsibility is clear. An unplanned production issue with no agreed support arrangement is genuinely expensive to resolve.

Is eight weeks a realistic timeline for a real product?

For a well-scoped MVP with one primary user type and a clear core journey, eight weeks is achievable with a senior-led team that designs before building and involves you in structured review points. It requires you to be responsive — design feedback in particular needs to come back promptly. Timelines stretch when scope is unclear at the start, when feedback is slow, or when additional features are introduced mid-build. The discipline of the checklist above is precisely what makes a short timeline realistic rather than optimistic.

What happens if I need to change something mid-build?

Changes mid-build are normal, but they need to go through a defined process rather than an informal message. A credible studio will have a change request process that assesses the impact on scope, timeline, and price before committing to the change. Changes that are agreed informally and then forgotten are one of the most reliable routes to a disputed delivery. Before signing, ask the studio how changes are handled and make sure the answer is documented in the contract.

Back to MVP Development Company UK: How to Choose, What to Pay, and What to Avoid

Sources

  1. What is a Minimum Viable Product (MVP)? | Agile Alliance
  2. Minimum viable product - Wikipedia
  3. Why Startups Fail: Top 9 Reasons l CB Insights

Work with Wall & Fifth

Have something to build? Let’s talk it through.

Start a conversationSee our work