Killing the Discovery Phase: Why We Replaced It With a Paid Architecture Sprint
Discovery phases rot. They produce PDFs nobody reads and estimates nobody trusts. Here's the paid architecture sprint we run instead, and why clients actually pay for it twice as often.
We stopped selling discovery phases about eighteen months ago. Not because they were unprofitable — they were fine — but because the deliverable was a lie. A 40-page PDF describing a system nobody had tried to build yet, priced as if the uncertainty had been removed. What we sell now is a paid architecture sprint, and it has changed how we close deals, how we estimate, and how we hand projects to delivery teams.
This is the actual playbook, including the parts that didn't work.
Why discovery phases quietly fail
The classic agency discovery runs two to four weeks. You interview stakeholders, map user journeys, produce wireframes, and deliver a scoping document with a fixed-price estimate attached. On paper it de-risks the main build. In practice:
- The people writing the document are rarely the people building the thing.
- No code gets written, so none of the assumptions get tested against reality.
- The estimate at the end is anchored on vibes and Figma, not on the integration that will actually eat your margin.
- Clients read the executive summary and file the rest.
We ran the numbers on a year of post-discovery projects. The ones where we'd done a traditional discovery overran by roughly the same margin as the ones where we'd skipped it. The document hadn't protected anyone. It had just made everyone feel better before the pain started.
The specific moment we gave up
We'd delivered a beautiful discovery for a logistics client — personas, data model diagrams, the lot. Week three of the build, we hit a hard constraint in their legacy ERP's webhook throttling that nobody had asked about during discovery because nobody on the discovery team knew to ask. That single issue cost us about six weeks of unplanned work. The PDF was a monument to everything we hadn't thought to check.
What a paid architecture sprint actually is
An architecture sprint is a two-week, fixed-price engagement with a working deliverable. It costs more than a traditional discovery — usually 1.4x to 1.8x — and it's run by the people who will lead the build, not a separate pre-sales team.
The outputs, in order of importance:
- A running scaffold repository with the chosen stack, CI, auth, and one real end-to-end flow wired up.
- A spike log documenting every integration we actually tried to call, with evidence (screenshots, response payloads, rate-limit observations).
- A decision record for the top ten architectural choices, written in the ADR format.
- A build estimate expressed as a range with explicit confidence levels per epic.
- A risk register with mitigations priced separately.
No persona posters. No journey maps unless the client specifically wants them and pays for them as an add-on. The goal is to reduce technical uncertainty, not to produce artefacts.
The scaffold is the point
The scaffold repo is what makes this work commercially. When a client sees npm run dev producing a logged-in user hitting their actual Salesforce sandbox on day ten, the conversation about the main build estimate becomes qualitatively different. They are not buying a promise; they are buying the continuation of something that already runs.
# What we hand over at the end of sprint
├── apps/
│ ├── web/ # Next.js scaffold, auth wired
│ └── api/ # One real endpoint per bounded context
├── packages/
│ └── integrations/ # Spikes against each third party
├── docs/
│ ├── adr/ # 10-15 architecture decision records
│ ├── spike-log.md # What we tried, what broke
│ └── estimate.md # Ranges per epic, with confidence
└── infra/
└── terraform/ # Dev environment, reproducible
The client owns this repo from day one. If they don't continue with us, they walk away with something a competent team can pick up. That asymmetry — we give them real leverage — is what makes them trust the estimate at the end.
How we price and sell it
Pricing is the part most agencies get wrong when they try this. If you price the architecture sprint like a discovery, you lose money, because the people doing it are your senior engineers, not your BAs. If you price it like consulting, the client balks because the number looks large next to the main build.
Our current structure:
- Fixed price, paid 50% on kickoff and 50% on delivery.
- Staffed by one tech lead and one senior engineer, full time, for two weeks.
- Priced at roughly the equivalent of three weeks of T&M at those rates.
- Includes a credit: if the client proceeds with the main build within 30 days, 50% of the sprint fee comes off the first invoice.
That credit is important. It reframes the sprint from "an extra expense before the real work" to "a prepaid deposit on the build, with an option to walk away." Our conversion from sprint to build sits well above our old discovery-to-build rate. We won't publish a specific number because sample size matters and ours is in the low dozens, but the shift has been obvious enough that we stopped offering the traditional discovery entirely.
The sales conversation
The pitch we use, roughly:
You can hire us to write a document that estimates your project, or you can hire us to build the first two weeks of your project and estimate from there. The second option costs a bit more, you own the code either way, and if you continue with us half of it comes back as credit. Which one would you rather be reading in a month?
Most technical buyers pick the sprint without much debate. Non-technical buyers need the credit explained twice, and sometimes a reference call with a previous client. We've only had one prospect insist on the old-style discovery in the last year, and we referred them to a competitor.
What we put in the two weeks
The sprint is tightly choreographed because two weeks disappears fast. Rough shape:
Days 1–2: Constraint hunting. Interviews are short and specifically technical. We want names of systems, versions, API docs, who owns the credentials, what the rate limits are, which team touched it last. Any system we can't get access to in week one becomes a flagged risk, not an assumption.
Days 3–7: Spikes. Each senior engineer owns two or three integrations. The rule is: no integration counts as "understood" until we have called it from code with the client's actual credentials and logged the response. Diagrams of what we think the API does are banned.
Days 8–11: Scaffold. We wire the chosen stack together with one real end-to-end flow — usually login plus one domain action that touches the most frightening dependency. This is where the ADRs get written, because you can't decide between Postgres and DynamoDB in the abstract, but you can decide it once you've tried to model the actual aggregate.
Days 12–14: Estimate and handover. We write the estimate with ranges per epic. Anything we didn't get to spike gets a wider range and goes in the risk register. We present to the client with the repo open, not a slide deck.
What we deliberately don't do
We don't produce polished UI. We don't write user stories for the full backlog. We don't do capacity planning for the build team. Those are build-phase activities, and dragging them into the sprint is how you end up back in discovery theatre.
The parts that didn't work
Two things we tried and dropped:
We tried running the sprint with a junior engineer paired with the tech lead, to improve margin. The junior spent too much time ramping on the stack and the client's domain, and the output quality dropped visibly. The sprint only works with people who can make architectural decisions in real time.
We tried offering a one-week version for smaller projects. It became a discovery phase with code attached — too little time to spike properly, so the estimate at the end wasn't meaningfully better. Below a certain project size, it's cheaper for everyone if we just quote T&M with a cap.
We also learned the hard way that the sprint needs a named client-side technical contact with real authority. Without one, the credential-gathering stage drags past day three and the whole schedule compresses. We now make this a contractual precondition, not a polite request. If you want more on how we structure those contracts, our services page has the current shape of our engagement models.
Where we'd start if you're copying this
If you run an agency and want to try it, don't rewrite your whole sales process. Pick the next prospect who asks for a discovery phase and offer them the sprint as an alternative, with the credit structure. Staff it with your best two engineers, not your pre-sales team. Make the scaffold repo the hero of the final presentation. Measure two things afterwards: whether they signed the build contract, and whether your delivery team felt the estimate was defensible when they inherited it.
If both answers are yes on the first two attempts, retire your discovery phase. It wasn't protecting you anyway.
Want a team like ours?
72Technologies builds production software for the kind of teams who actually read this blog.
Start a projectKeep reading
The Statement of Work Is a Product: How We Rewrote Ours After Losing Three Fixed Bids in a Row
An SOW isn't paperwork. It's the first thing your client reads in anger when a project goes sideways. Here's how we rebuilt ours to actually protect both sides.
The Equity Deal That Almost Sank Us: A Framework for Agencies Taking Stock Instead of Cash
Taking equity from a client sounds like free lottery tickets. It isn't. Here's the framework we use to decide when stock beats a wire transfer — and when it's just a discount with extra paperwork.
The Retainer Ladder: How We Turned One-Off Clients Into Monthly Revenue Without Becoming a Support Shop
Most agencies bolt on retainers as glorified bug-fix contracts and burn goodwill within six months. Here's the tiered model we use to convert project clients into monthly revenue that engineers actually want to work on.
