The Prototype Sprint is seven days from a discovery call to a real, deployed, clickable prototype — working code on a production URL, not a Figma file. It costs $3,500 fixed, the code is yours, and the price is credited toward a full build if you continue. One core flow, built properly, beats any deck for convincing stakeholders, users or investors.
Why deployed beats slides
A slide deck asks people to imagine the product. A URL lets them use it. The difference shows up everywhere that matters:
- Stakeholders stop debating hypotheticals. "Would the team use this?" becomes "watch Maria try it." Arguments about imaginary software last forever; arguments about real software end in minutes.
- Users give real feedback. People are polite about mockups and brutally honest about things they actually click. You want the brutal version before the full build, not after.
- Investors and buyers feel momentum. A live URL in week one says more about execution than any roadmap slide.
- The spec writes itself. Nothing surfaces the real requirements like watching someone use the almost-right thing. The prototype is requirements discovery disguised as software.
The seven days
- Day 1 — the discovery call. Ninety minutes. What the business does, what the software must prove, and — hardest part — what the one core flow is. Everything else gets written on the "later" list, out loud.
- Day 2 — skeleton on a live URL. Data model, repo, deploy pipeline, and a walking skeleton in production by evening. From day two, every change ships to the same URL you'll demo from. There is no "we'll deploy it at the end" — deployment is the beginning.
- Days 3–5 — the core flow, built properly. The one thing the prototype must prove, made real: real screens, real data, real state. AI handles the volume, humans handle the judgment — same stack as our full builds, because the prototype becomes the full build.
- Day 6 — polish and hard edges. Empty states, error states, mobile, and the demo path made bulletproof. A prototype that crashes mid-demo is worse than no prototype.
- Day 7 — the walkthrough. We demo it, you drive it, then we hand over the keys: repo, URL, accounts. You also get our honest read on what the full build would cost and take — in real numbers.
What a sprint prototype is — and isn't
It is: real working code, deployed, built on the same foundations as a production system. If you continue to a full build, the sprint's code and the $3,500 both carry forward. Nothing is thrown away.
It isn't: the whole product. It's one core flow with honest edges — auth might be simple, admin might be minimal, integrations might be stubbed. We'll tell you exactly which corners are real and which are painted, because a prototype that lies to its own stakeholders is a liability.
The three rules that make a week enough
- One decision-maker. Sprint weeks die in committees. One person owns the calls; everyone else advises.
- Answers within a day. When we hit a fork — "cash or card pricing? per-unit or per-order?" — a same-day answer keeps the week on rails.
- The scope stays frozen for seven days. Every good idea that appears mid-week goes on the "later" list. On day seven you'll have a working prototype and a prioritized backlog — instead of 60% of two different prototypes.
Who this is for
The sprint fits three situations almost perfectly: a founder who needs to show something real to co-founders, users or investors; a business owner who wants to de-risk a bigger build before committing to it; and a team that's argued about a tool for months and needs the argument settled. If that's you, it's $3,500, one week, fixed — the smallest honest way to find out.