Discovery to Launch in 12 Weeks: What Actually Happens Each Week

A week-by-week account of a real product build, from problem framing through design, sprints, QA and launch, including the decisions that saved time and the one that cost it.

Discovery to Launch in 12 Weeks — Blurbee Solutions

This is one build, described honestly, including the week that went wrong. It is not a template that fits every project — but the shape holds, and the two decisions that make it work are both made before any code exists.

The product: an operations portal for a mid-size logistics client, replacing a spreadsheet-and-email process. Three integrations, two user roles, a reporting requirement. A team of four plus a delivery lead.

Weeks 1-2: discovery, and the cut

Discovery produced four things, none of them long.

A written statement of outcomes. Three sentences: reduce order handling time, eliminate the daily reconciliation email, give dispatch visibility of exceptions without asking. Every subsequent scope argument was settled by asking which of those three a feature served.

A technical spike on the genuinely unknown. One of the three integrations was against a system whose documentation was five years old. We spent two days proving we could read from it before anything else was planned. This turned out to be the single most valuable two days of the project — the API worked, but paginated differently than documented, which would have been a week's surprise in month two.

A decision about who approves. One person, named, with the authority to say yes. This sounds administrative and it is the most common cause of overrun we see: four stakeholders each with veto and none with ownership. Review cycles never converge, and the timeline dies quietly.

The cut. The original list had twenty-three features. We shipped nine. The cut was written down as a phase-two list rather than deleted, which made the conversation considerably easier — nothing was being taken away, it was being sequenced.

That 60% cut is typical. It is also the thing that makes twelve weeks possible, and pretending otherwise is how a twelve-week plan becomes a twenty-week project.

Weeks 3-4: design, and something in production

Design ran in parallel with the first build week rather than sequentially. Wireframes and a clickable prototype for the two flows carrying the most business risk; high-fidelity screens for those only. The remaining screens were designed during weeks 5-8, one iteration ahead of the build.

More importantly: week three ended with something in production. Authentication, one read-only screen showing real data from the real integration, deployed behind a feature flag to two internal users.

This is the practice we argue hardest for. A deployment pipeline that has never been used is a hypothesis. Getting one real thing to production in week three exercises the environment, the build, the release process, the monitoring and the rollback path while the stakes are near zero. Discovering that your staging environment does not actually match production, or that nobody has tested a rollback, is a week-eleven catastrophe and a week-three inconvenience.

Weeks 5-8: the core iterations

Two-week iterations, a demo on real infrastructure at the end of each.

The demo is where scope misunderstandings surface, and it surfaces them cheaply. Twice in this project the client saw something working and said "that is not quite what I meant" — both times in week six or seven, both times a two-day adjustment. The same realisation in week eleven is a fortnight.

Instrumentation went in from the first build, not after launch: error tracking with stack traces and release attribution, latency and error rate per endpoint, and a small set of product events tied to the three stated outcomes. Not analytics on everything — a focused set someone would actually look at.

Week 7 is where it went wrong. The reporting requirement, which had been described as "a weekly summary," turned out to mean a reconciliation report with a specific layout the finance team already used and had not shown us. That was a week of rework, and it came out of the buffer.

The lesson is specific: any deliverable described in terms of a document should be seen before it is estimated. We asked what the report should contain. We should have asked to see the one they use now.

Weeks 9-10: hardening

Everything that is not a feature, and it is genuinely two weeks of work:

Real-device and cross-browser testing, not simulators. Accessibility pass to WCAG 2.2 AA — automated tooling plus manual keyboard, focus order and screen reader checks. Load testing against expected peak, which for a logistics client meant the Monday morning surge rather than an average. Error handling for the paths nobody demos: expired sessions, permission denied, an integration timing out mid-transaction. Monitoring and alerting routed to a named person. Documentation and a runbook for the first week after launch.

The error-path work is the part clients most often try to cut and most often regret cutting. Most of a user's real experience of software happens at the edges.

Weeks 11-12: launch, progressively

Not a launch day. A launch sequence.

The flag opened to a group of six dispatch staff for three days, with the old process still running in parallel. Then to one depot. Then to all users at the end of week eleven, with the old process available for a further fortnight.

Progressive rollout means a problem is a flag toggle rather than a rollback, and the first real usage happens while the audience is small enough to speak to individually. Two usability problems came out of those first three days — both small, both fixed before the wider rollout, neither of which had appeared in any demo.

Week twelve was deliberately quiet: monitoring, small fixes, the handover walkthrough with the client's own developer, and a written list of what was cut and why.

If week twelve is dramatic, something was postponed that should have been raised in week six.

The two things that made it work

One decision-maker, available within a business day. This is the strongest predictor of whether a twelve-week build finishes in twelve weeks. Not the methodology, not the stack, not the team's seniority.

An honest cut in week two. Nine features shipped out of twenty-three proposed. Written down as a sequence rather than a deletion, so nobody felt they had lost an argument.

The two things that nearly broke it

A deliverable described rather than shown. The reporting requirement cost a week because we estimated from a description instead of the existing artefact.

Content and data readiness. Not on this project, but it is the most common cause elsewhere. A build that proceeds against placeholder content breaks when real content lands — real copy is longer, real data has edge cases, real images are the wrong ratio. If content is not ready in week two, that should change the plan rather than being absorbed silently.

Hold two weeks of buffer

Twelve weeks of plan, ten weeks of committed features. The buffer always gets used — by an integration behaving differently than documented, a security review taking longer than scheduled, or content arriving late.

A plan with no buffer does not go faster. It slips publicly instead of absorbing quietly, and it does so at the least convenient moment.

Running this with a distributed team

This is how we run it, across a time difference. The requirements are the same as any distributed engagement and none of them is exotic.

Written scope, so ambiguity does not cost a day per clarification. One decision-maker reachable within a business day. A standing call inside the overlap window, focused on decisions rather than status. A written handoff at the end of each India day: what moved, what is blocked, what needs a decision. And a dated decision log, because "we agreed that on a call" is not a record.

The twelve weeks do not change. The communication discipline has to be real rather than intended.

The twelve weeks, in numbers

Week 3When something reaches production. Not week 12 — week 3, behind a flagBlurbee delivery practice
1Decision-maker. Two approvers with veto and no owner is what breaks timelinesBlurbee delivery data, 2019-2026
~40%Of the original feature list that typically ships in a 12-week buildBlurbee delivery data
2 weeksBuffer held back and not committed. It always gets usedBlurbee delivery practice
How the twelve weeks divide

Blurbee delivery data across product builds, 2019-2026. Distribution varies with integration count and content readiness.

  • Discovery & framing Weeks 1-2
  • Design & first build Weeks 3-4
  • Core iterations Weeks 5-8
  • Hardening & QA Weeks 9-10
  • Launch & stabilise Weeks 11-12
Weeks

Why we structure builds this way

Twelve weeks is not a promise about every project — it is what happens when scope is cut honestly in week two and one person can decide. Both of those are choices made before any code, and they are the whole difference.

  • Fixed-scope first projectTwo to four weeks, priced as a number rather than an estimate, so you have evidence before a longer commitment.
  • One delivery lead, namedYou always know who to ask. No account manager relaying questions to a team you never meet.
  • Code and IP are yoursAssigned in writing, handed over with repositories, infrastructure definitions and documentation whether or not you continue with us.
  • Performance budgets in CICore Web Vitals and bundle size gate the build. Slow does not ship.
  • Accessibility to WCAG 2.2 AAReviewed with automated and manual passes, not claimed on a slide.
  • Written overlap disciplineStanding calls inside your working window, everything else asynchronous with a decision log.

Frequently asked questions

Frequently asked questions

Is twelve weeks realistic for a real product?

What makes a twelve-week build fail?

Why does something ship in week three rather than week twelve?
What is in the two weeks of discovery?
Do you really cut 60% of the feature list?
How do you handle the two-week buffer?
What happens in the hardening weeks?
Do you launch to everyone at once?
What does week twelve actually look like?
Can this run with an offshore team?

Start with a fixed-scope first project

Two to four weeks, priced as a number. Code, accounts and IP stay in your name.