Prototype Sprint
A prototype ready to test in three days.
Three working days to isolate the riskiest assumption, build the prototype that tests it, and hand your team the rubric to run it against real users.
Why this exists
One credible prototype against the riskiest assumption, plus a test protocol your team can run with real users. You bring the team and the testing; I bring the facilitation, the prototype, and the rubric.
Your team can ship a Lovable or v0 prototype before lunch. The product here isn't the Figma file. It's the facilitated work that picks the right assumption to put on trial, defines what would falsify it, and writes the rubric your team takes to real users. The prototype is the embodiment of that work, not the work itself.
Who this is for
The Prototype Sprint is the smallest possible engagement that produces real evidence. It works in a narrow situation; outside it, the wrong tier wastes both our time.
Strong fit
Teams aligned on the goal but uncertain about the riskiest assumption underneath it
Founders with one bet that, if wrong, changes the whole quarter
Pre-build engagements where shipping the wrong thing is the larger risk
Teams able to recruit and run the user tests themselves with a written rubric
Not a fit
Teams that haven't aligned on the goal yet (do the Strategy Deep-Dive first)
Engagements that need moderated user testing or a multi-expert team (do the Discovery Workshop)
Solo founders who can ship and test a credible prototype themselves over a weekend
Teams already committed to building, looking for design support rather than evidence
Before we start
Three conditions that need to be true on day one. If any are missing, the engagement won't return what it should.
A defined assumption you want to put on trial, even if it shifts during framing
Your team available for three working sessions across one calendar week
Internal capacity to recruit users and run the tests after the engagement closes
How it works
Three working sessions across three days, with an async intake the week prior. The short window forces the team to commit to one assumption and keeps the work from drifting off it.
Framing the problem
A working session with your team to surface the assumptions everyone is treating as facts and agree on the riskiest one to put on trial.
Mapping the solution
A working session to translate the assumption into a concrete solution direction the prototype can embody. Prototype build runs in parallel, off-session.
Designing the user tests
A working session to write the test protocol: tasks, prompts, what to listen for, how to score the result. You leave with the prototype and the rubric to run the tests yourself.
What you walk away with
Three concrete artifacts, ready to hand to the team and act on immediately.
Bet brief
The riskiest assumption in one sentence, the test in one paragraph, and the recommended next move once you have evidence.
Test protocol
A short script you can hand to a researcher or run yourself: tasks, prompts, what to listen for, what to ignore.
High-fidelity prototype
Realistic enough to surface real behavior, disposable enough that no one is precious about throwing it away.
Pricing and scope
Includes
Async intake and assumption mapping
3 facilitated working sessions: problem framing, solution mapping, test design
High-fidelity prototype, built off-session, ready to put in front of users
Test protocol and bet brief: assumption, falsification criteria, next move
Excludes
Moderated user testing (you run the sessions)
Participant recruiting
Implementation or build support
If the intake call surfaces that your assumption doesn't justify a sprint, I refund the deposit and point you at the Strategy Deep-Dive instead.
Have an assumption that is doing all the work?
Send a short brief: the idea, the user, and the assumption carrying the most risk. We'll take it from there.
Start with a brief