What Does the MVP Development Process Look Like, Week by Week?

The MVP development process runs in 5 stages over 6–12 weeks: a 30-minute scoping call (day 0), a written scope and fixed price (within 5 working days), design one to two weeks ahead of code (from week 1), a deployed build demoed every week (from week 2), and ship, run and hand over (weeks 6–12). That is how Kinetico, a product design and engineering studio, runs it; because the same people design and build, there is no handoff stage.

Most guides to the MVP process are step-lists — 4 steps at Toptal, 9 at ScienceSoft — that tell you what to think about and not when it happens or who does it. This one is a calendar. It is the process behind our MVP development service (branch 4 of our guides), and the weeks and tiers here are the same as on that page and in the cost guide, so nothing on this site disagrees with itself.

What are the stages of the MVP development process?

Five, and each has a date, an output you can point at, and a characteristic way of going wrong:

Compare that with the published step-lists. ScienceSoft's nine steps put “design MVP UX and UI” as step 5, then back-end, then front-end, then testing — a strictly sequential process with design finished before code starts, and design and coding described as separate phases. Toptal's four steps are all design (PRD, information architecture, wireframes and prototypes, design QA) and end where engineering begins. Neither is wrong; both describe a process with a handoff in the middle of it, which is the thing this article is about.

How long does the MVP development process take, week by week?

6–12 weeks depending on tier. This is the Standard tier — 2 user roles, 12–20 screens, core workflow plus admin, payments or 2 integrations — as two parallel tracks. Read it across: design is always one to two weeks ahead of the build it feeds.

Two things to notice. The first deployed demo is in week 2, not week 8 — from then on progress is a URL you log into, not a percentage. And design QA (week 6) is against the running build, by the people who designed it, before the QA and performance week. The other tiers compress or extend the same shape:

For contrast, ScienceSoft publishes an MVP timeline of “from 2 weeks to 8 months” depending on approach — true, and not something you can plan a raise around. Fixed weeks are only possible because the scope is written first; the week-by-week for the Lean and Full tiers is in the MVP cost guide.

Where does the design-to-development handoff fit — and why is it the risky stage?

In the common two-vendor process the handoff sits between “design done” and “engineering starts”: a Figma file, some annotations, and a call. It is where MVPs lose weeks, because nothing on the design side was built to survive being read by strangers later. Here is the same six moments in a two-vendor process and in a one-team process:

If you are stuck with two vendors, the mitigations are known: keep the designer engaged through the build, put the design system in code rather than only in Figma, and schedule design QA against the running product (Toptal's fourth step). They cost weeks and a second invoice. The reason we scope prototype and MVP as one engagement — the case made in PoC vs prototype vs MVP — is that the prototype simply becomes weeks one and two of the build, and the handoff never happens.

What actually happens in each stage?

Stage 1 — the scoping call (day 0)

Thirty minutes. You bring the problem you are solving, the constraint (budget and date), and whatever exists — a deck, a Figma file, a spreadsheet, a no-code prototype. The most useful thing you can say is the sentence that starts “I don't know if…”: it tells us which risk the MVP has to retire, which decides the tier. We will ask what we can remove; a good answer to that question is worth more than a feature list.

Stage 2 — the written scope and fixed price (within 5 working days)

Modules, screens, states, integrations, weeks and one number, in a document you can send to another vendor for a like-for-like quote. Nothing starts until it exists. It is also the contract for change: swaps of the same size are absorbed inside the price; additions are written up with their weeks and cost before any work starts.

Stage 3 — design, one to two weeks ahead of code (week 1 →)

Week 1 locks the data model and the core flows. From week 2 the designers are one screen-set ahead of the build: role-one screens with every state, then role-two and admin, then payments and settings, then the empty, error and edge states — in that order, because that is the order the build needs them. The design system (tokens, components) lives in the repository, so the product and the design cannot drift apart. The people doing this are the same people writing the code, which is why there is nothing to hand off.

Stage 4 — build with weekly demos (week 2 →)

Week 1 sets up the repository in your GitHub organisation, CI, auth and the database. Week 2 ships the first deployed, signed-in build. The core workflow goes end to end before anything else is broadened; then admin, roles and permissions; then payments or integrations. Every week you get a URL and an hour: use the build, decide the open questions, set the priority. TypeScript end to end — React with Next.js, a typed backend, PostgreSQL — deployed in your accounts.

Stage 5 — ship, run, hand over (weeks 6–12)

Design QA against the build, then a QA and performance week with monitoring wired, then production deploy, documentation and the handover: repository, deployment accounts, design files and docs in your name. There is no licence, retainer or lock-in required to keep running what was built. Then the MVP goes and does its job — finding out whether people come back and pay — which is a different process, and yours.

What does the founder do during the MVP development process?

Less than you fear, and not nothing. The failure mode on the founder side is either disappearing (and finding out at launch) or re-scoping every Monday. The job, by week:

How do you keep the MVP from being rewritten at traction?

The MVP is v1, not a draft — the code you keep. Four process choices make that true without slowing week 6:

• A boring stack you can hire for. TypeScript, React with Next.js, PostgreSQL. It costs no more to build on, and it is the largest hiring pool if the work moves in-house — see Next.js and React development.
• Tests where they pay: in the QA line, on the core workflow and the money paths. Full coverage on an MVP is a way to spend week 6 twice; no tests is a way to spend year two on a rewrite.
• Monitoring from the first deploy. Logs and error tracking in week 2 cost an afternoon; adding them after the first outage costs a customer.
• Roles and integrations as written changes, not mid-build surprises. The second role is a full tier of work; adding it by stealth in week 5 is how architectures get bent. Add it as the next engagement, on the same codebase.

What is not on the list: micro-services, multi-region, a platform team. Those are what “from MVP to enterprise” means later, and the process above is designed so that when the day comes it is an extension, not a restart.

Frequently asked questions

What is the MVP development process?

The MVP development process is the sequence from idea to a deployed first version real users can sign into. In Kinetico's engagements it has five stages: a 30-minute scoping call (day 0); a written scope and fixed price (within 5 working days); design running one to two weeks ahead of code (from week 1); build with a deployed, signed-in demo every week (from week 2); and ship, run and hand over (weeks 6–12). Published step-lists elsewhere run from 4 steps (Toptal) to 9 (ScienceSoft); the difference is whether design and engineering are one team or two.

How long does the MVP development process take?

6–12 weeks in Kinetico's tiers: 6 weeks for a Lean MVP (1 role, one core workflow), 8 for Standard (2 roles, admin, payments or 2 integrations), 10–12 for Full (3 roles, billing, notifications, reporting) — plus up to 5 working days for scoping before week 1. ScienceSoft publishes 2 weeks to 8 months depending on approach. Timelines stretch when a second vendor has to re-interpret the design or when scope changes arrive without a written change.

What are the steps to build an MVP?

Decide the one risk the MVP must retire; write the scope down (roles, screens, states, integrations, weeks, price); design the flows and every state one to two weeks ahead of code; build the core workflow end to end first and demo a deployed build weekly; wire payments or integrations; QA against the design and the scope; deploy in your own accounts; hand over the repository, design files, docs and monitoring. Kinetico runs those as five stages over 6–12 weeks.

What is the design-to-development handoff, and how do you avoid problems with it?

The handoff is the point where finished designs (usually Figma) are passed to a separate engineering team to build. Problems come from re-interpretation: unspecified states, spacing and behaviour guessed at, screens that drift from the design, and QA against static mocks. You avoid it either by keeping the designer in the build with a coded design system and design QA against the running product — or, as Kinetico does, by having the same people design and build so there is no handoff stage at all.

What happens after the MVP launches?

Handover, then learning. At handover you own the repository, deployment accounts, design files and documentation, with monitoring in place; no retainer is required to keep it running. Then the MVP does its job: real usage answers whether people come back and pay. Keep it from becoming a rewrite by shipping on a standard stack, keeping tests in the QA line, and adding integrations and roles as written changes rather than mid-build surprises.

How much does the MVP development process cost?

$15,000–$50,000 fixed at Kinetico: Lean $15k–$22k over 6 weeks, Standard $22k–$35k over 8 weeks, Full $35k–$50k over 10–12 weeks, with scoping inside the price. The money splits roughly scoping 5–10%, design 20–25%, engineering 50–60%, QA and handover 10–15%. Market ranges and the full breakdown are in our MVP cost guide.