Technical Spike Template: Time-Box a Risky Unknown in 3 Days
Three days of honest probing can save three months of building something impossible. Time-box the scary part and write down what you learn.
Share
A technical spike is a time-boxed technical probe of the riskiest part of an idea, ending with a written note on what is now known and what is still open. One or two engineers build only enough to answer one question, such as "Can we hit 95% accuracy at under €0.05 a page?", and usually throw the code away. This spike template gives you the question sheet, the pass signal and the log.
Key takeaways
The spike comes from Extreme Programming. Don Wells described it in 1999 as a very simple program built only to explore one problem, and said to expect to throw it away (ExtremeProgramming.org).
Time-box it. Three days is a good default; Scrum Alliance's Agile Atlas puts the upper bound at one sprint (Scrum Alliance, 2014).
Write the target in numbers before you start: speed, cost and accuracy. "It seems to work" is not a result.
Strategyzer rates the spike 5 out of 5 for evidence strength on feasibility, at a cost of 2 out of 5. It says nothing about whether customers want the result.
Small test sets mislead: 34 of 35 correct looks like 97%, but the honest range runs from about 86% to over 99%.
What is a technical spike?
A technical spike is a time-boxed technical probe of the riskiest part of an idea, ending with a written note on what is now known and what is still open.
The term comes from Extreme Programming. Don Wells' 1999 rule says the goal is to reduce the risk of a technical problem or make a user story's estimate more reliable. When a technical difficulty threatens to hold up development, his advice was to put a pair of developers on it for a week or two.
The Scaled Agile Framework calls a spike an exploration enabler story that gains the knowledge needed to reduce the risk of a technical approach (SAFe glossary). SAFe spikes are estimated and demonstrated like other stories (SAFe, Spikes).
In David J. Bland and Alex Osterwalder's Testing Business Ideas, the "Extreme Programming Spike" is the only experiment on Strategyzer's poster tagged for feasibility alone. It rates the spike 2 out of 5 for cost, 1 out of 5 for setup time, 2 out of 5 for run time and 5 out of 5 for evidence strength ().
Use it when the plan rests on something your team has not done before: a model's accuracy, a third-party API, a data volume, a response time. Better to spend three days learning that something is impossible than three months finding out.
Do not use it for a question about customers. It tells you nothing about whether anyone wants the result. And do not let a spike turn into the first sprint of the real build. The code is there to answer the question, and is usually thrown away. If you can avoid building anything by connecting existing tools, try a mash-up.
Use them sparingly. Mountain Goat Software calls spiking too often a common mistake, because it delays value (Mountain Goat Software, 2024). The Agile Atlas goes further: every story carries some uncertainty, so reserve a spike for the larger unknowns and try splitting the story first.
Which risk does it test, and how strong is the evidence?
This tests feasibility: does the risky part work at the speed and cost you need? The evidence is directional, since a probe under ideal conditions may behave differently in production, with real data and real load. In our guide to choosing a product experiment, you will see it is about removing one unknown.
That is stricter than Strategyzer's 5-out-of-5 rating, on purpose. A spike proves something can work under the conditions you tested. It does not prove it will work at ten times the volume, on next year's data, with the edge cases you did not sample.
Technical spike template (copy and use)
Open the image at full size, or copy the text version below.
Who to recruit and how many
One or two engineers. No customers. Choose someone who is willing to throw the code away.
Step-by-step plan
Write the one question this spike must answer.
Set your pass signal, with numbers.
Set the time box. Three days is a good default.
Build only what answers the question.
Use realistic data, even if you only have a little.
Stop when the time is up, even if unfinished.
Write what is now known and what is still open.
Question sheet
Item
Your answer
The one question
Why it's the riskiest part
Speed needed
Cost needed
Accuracy or quality needed
Time box (days)
What we will NOT do in this spike
What we learned
Write this at the end:
Now known: what the spike showed, with numbers.
Still open: what we still cannot say.
Conditions: what data or setup these results depend on.
Recommendation: go on, change the approach, or stop.
What to measure
Whatever your pass signal named: latency, cost per call, accuracy on a small labelled set, throughput.
Pass signal to set before you start
Specky's starting point: the risky part works at the speed and cost you need, inside the time box. This is a starting point, not a benchmark. Replace "the speed and cost you need" with real numbers, or you will end up debating it later.
Results log
Question
Target
Measured
Data used
Inside time box?
Now known
Still open
How long should a technical spike take?
Long enough to answer the question, and no longer than you agreed up front.
Source
Time box
Extreme Programming (Don Wells, 1999)
A pair of developers for a week or two
Scrum Alliance Agile Atlas (2014)
One sprint at most; if you estimated four hours, spend four hours
This template
Three days by default
Three days is long enough to wire up a real API and run real data through it, and short enough that nobody quietly starts building the product. If the question needs more than a week, it is probably two questions. Split it.
How big should a spike's test set be?
Big enough that the number means something. Accuracy measured on a handful of samples has a wide margin of error, so "34 out of 35" is not "97%, done".
Here is the arithmetic, using a 95% confidence interval (Wilson method):
Correct / tested
Measured accuracy
Plausible range
44 / 50
88%
76% to 94%
34 / 35
97%
86% to over 99%
97 / 100
97%
92% to 99%
291 / 300
97%
94% to 98%
485 / 500
97%
95% to 98%
Two decision rules follow:
A spike can rule things out quickly. If the whole range sits below your target, the approach fails as specified. You do not need more data to stop.
Confirming a tight target takes more data than a spike usually has. To show at least 95% with any confidence, at a measured 97%, you need roughly 500 labelled samples. Plan that as a follow-up, not as part of a three-day spike.
What does a spike look like in practice?
This example is made up to show the method. A team plans to extract line items from scanned delivery notes. The plan works only if accuracy is at least 95% and each page costs under €0.05 and takes under 10 seconds. They give it three days.
Using 50 real, messy delivery notes, they reach 88% accuracy at €0.03 a page in six seconds. Handwritten quantities cause almost all of the errors. On printed notes alone, accuracy is 97%.
The target was missed, so the spike fails as written. But the team now knows something specific: the printed-note version is feasible, and handwriting is the open question.
Here is how the numbers could break down. Of the 50 notes, 35 were printed and 15 handwritten. The model got 34 of 35 printed notes right (97%) and 10 of 15 handwritten (67%), for 44 of 50 overall (88%). The overall result is clearly short of 95%, since its range tops out at 94%. The printed-only result is promising but not proven.
The write-up:
Now known: printed notes work at €0.03 and six seconds per page.
Still open: printed accuracy at scale; any route for handwriting.
Conditions: 50 notes from two suppliers; one scanner.
Recommendation: change the promise to printed notes only, and label 500 printed notes before launch.
Two engineers for three days is six engineer-days. A three-month build by the same two engineers is roughly 120 engineer-days, 20 times as much, to learn the same thing.
Technical spike vs proof of concept vs prototype vs Wizard of Oz
Do customers value the result, before it's automated?
Audience
The team
The team or stakeholders
Customers
Customers
Built by
1-2 engineers
Engineers
Designer
A person doing the work by hand
Typical length
Days
Days to weeks
Days
Days to weeks
Code kept?
Usually not
Sometimes
No code
No code
The Agile Atlas lumps prototypes and proofs of concept in with spikes. The useful line is the audience: a spike answers a technical question for the team, while prototypes and Wizard of Oz tests answer questions about customers.
What are the most common spike mistakes?
No time limit. Without one, a spike quietly turns into the project.
Keeping the code. Spike code tends to be built with shortcuts.
Using clean test data. Real inputs are messier.
Having no target. "It seems to work" is not a result.
Skipping the write-up. The learning is the deliverable.
Trusting a tiny test set. 34 of 35 is promising, not proof.
When it doesn't work: for problems that only appear at production scale or over months, such as drift, load spikes or rare edge cases. A spike lowers the risk; it does not remove it.
Is it safe to use real customer data in a spike?
Realistic data matters, but real data has real owners. Use data you are allowed to process for this purpose, strip names and personal details where you can, and check before sending customer documents to a third-party API you have not yet reviewed. Delete the copies when the spike ends.
How to run it in Specky
On the Assumptions page, click the note and choose Pick a test, then Extreme programming spike. Specky fills in the steps, the pass signal, and a three-day timeline.
You run this one. Specky keeps the plan and the result. Your engineers do the work.
Click Start running. Paste "now known" and "still open" onto the test.
Record the result.
A pass shows as Early signal on the board, not Supported, because a probe is rated directional. It removes a doubt, but production will still have surprises.
What should you do with each outcome?
Supported (shows as Early signal): The risky part looks possible. See how it holds up with customers using a single-feature MVP.
Unclear: Ran out of time, or the result depends on something you have not tried. Write down what is left and decide if it deserves another time box.
Contradicted: It does not work at those numbers. Change the approach or change the promise. A person behind the scenes via a Wizard of Oz test may buy you time. Any bet resting on this note now shows as Contradicted.
A technical spike is a short, time-boxed investigation that answers one risky technical question, such as whether an API is fast enough or a model accurate enough. The term comes from Extreme Programming. The output is what the team learned, written down with numbers, and the code is usually thrown away.
How long should a technical spike take?
Most spikes should take one to three days. Extreme Programming's original guidance allowed a pair of developers a week or two, and Scrum Alliance's Agile Atlas sets one sprint as the upper limit. If you need longer, split it into smaller questions or decide whether it is worth continuing.
What is the difference between a spike and a prototype?
A spike answers a technical question for the team. A prototype shows an experience to customers. A spike's output is a number and a recommendation, such as "88% accuracy at €0.03 a page"; a prototype's output is how people behaved.
What should a spike template include?
One question, the numeric target for speed, cost and quality, a time box in days, what is out of scope, and a results log. At the end, record what is now known, what is still open, the conditions the result depends on, and a recommendation: go on, change the approach, or stop.
Should spikes be estimated in story points?
Teams differ. SAFe estimates spikes like other stories, and the Agile Atlas estimates them as tasks during sprint planning. The hard time box matters more than the unit: if you planned three days, stop at three days and write up what you know.