Technical spike

Short definition

A technical spike is a time-boxed research activity used to explore an unknown technical area, validate an approach, or reduce risk before full development begins.

Extended definition

Technical spikes help teams investigate uncertainties in architecture, integrations, performance, or implementation details. Instead of committing to a large engineering effort with unclear requirements, teams run a spike to gather insights and prototypes. The output is not production code but learning that informs upcoming work, improves estimates, and reduces delivery risk. Spikes are common in Agile environments, especially when dealing with novel technologies, complex systems, or unclear constraints.

Deep technical explanation

Spikes involve structured exploration with defined goals.

Time-boxed research

Spikes are tightly constrained in duration, often a few hours to a few days. The goal is not perfection but clarity. Time boxing ensures spikes do not become unbounded experiments.

Problem framing

A spike begins with a clearly defined question or uncertainty. Examples include:

Can this API support the required throughput?
How do we integrate with a particular authentication mechanism?
What library best fits a performance requirement?
How should an event-driven architecture be modeled for this use case?

Output expectations

Spikes produce knowledge, not features. Typical outputs include:

prototype code
architectural diagrams
performance benchmarks
risk assessments
recommendations or decision documents

Risk reduction

Spikes reduce unknowns that would otherwise disrupt sprint commitments. Teams often use spikes when:

legacy systems contain undocumented logic
multiple architectural paths exist
integration constraints are unclear
performance expectations are uncertain

Technical discovery

In a spike, engineers frequently explore:

libraries and frameworks
proof of concept architectures
data modeling approaches
cloud service capabilities
potential bottlenecks
security implications

Decision support

Spike results help teams choose the most appropriate solution. They also provide estimates for epics and stories by clarifying the complexity involved.

Practical examples

Testing whether a third-party API meets latency requirements
Prototyping a microservice to evaluate a chosen framework
Exploring database schema options for a scalability requirement
Building a minimal RAG pipeline to validate the feasibility for an AI assistant
Running load tests to determine if autoscaling meets performance targets

Why it matters

Technical spikes prevent wasted effort by uncovering hidden complexities early. They enable better planning, reduce rework, and help teams make informed architectural decisions. Without spikes, teams risk committing to designs that later prove infeasible or inefficient.