Splitting User Stories: Techniques That Work (SPIDR, Vertical Slicing and More)
Almost every Scrum team has met the story that "takes the whole Sprint" and then does not finish. Large stories hide risk, resist estimation and block flow. The cure is learning to split stories well. Done badly, splitting produces technical fragments that deliver no value. Done well, it yields small slices that each give users something real and give the team fast feedback. This lesson covers why splitting matters, the vertical slicing mindset and a toolkit of patterns you can use in refinement.
Why Small Stories Matter
- Predictability. Small items are easier to estimate and less likely to hide surprises.
- Flow. Several small items finishing during the Sprint are better than one large one that finishes on the last day, or not at all.
- Feedback. You learn sooner whether you are building the right thing.
- Risk reduction. If something goes wrong, less work is wasted.
- Sprint Goal focus. Small slices allow the team to adjust scope and still achieve the goal.
As a rule of thumb, aim for stories that a team can complete in a few days, so that several fit in a Sprint. See User Stories in Scrum for the basic format.
Horizontal vs Vertical Slicing
Horizontal slicing splits by technical layer: one story for the database, one for the API, one for the user interface. None of these delivers value on its own, and nothing can be demonstrated until all are complete.
Vertical slicing splits so that each slice cuts through all layers and delivers a thin but usable piece of functionality. A vertical slice can be demonstrated and, ideally, released. Think of cutting a layered cake from top to bottom, so each piece has all the layers, rather than separating the layers.
The SPIDR Technique
Mike Cohn's SPIDR gives five ways to split a story. SPIDR stands for Spikes, Paths, Interfaces, Data and Rules.
S: Spikes
When the team lacks the knowledge to estimate or split a story, run a time-boxed investigation first. The output is learning, not a feature. See Technical Debt and Spikes in Scrum.
P: Paths
Split by the different paths a user can take through a flow. As a shopper I can pay for my order becomes: pay by card, pay by wallet, pay by bank transfer. Start with the simplest path.
I: Interfaces
Split by the interface or platform: web first, then mobile; English first, then other languages; one browser first.
D: Data
Split by the type or amount of data supported: import CSV files before supporting Excel; handle one currency before many.
R: Rules
Split by business rules or variations: allow standard discounts first, then loyalty discounts, then stacking rules.
Other Useful Splitting Patterns
| Pattern | Example |
|---|---|
| Workflow steps | Split "manage leave requests" into: submit, approve, cancel, report |
| CRUD operations | Create first, then view, then edit, then delete |
| Happy path first | Build the main success scenario, then error handling and edge cases |
| Simple to complex | Begin with the simplest rule set, then add variations |
| Performance later | Make it work, then make it faster, if performance is not initially critical |
| Major effort | Split where most effort lies and deliver the rest quickly, for example separating a heavy integration |
| Defer non-critical qualities | First release with basic styling, then refine the design |
A Worked Example
Original story: As an HR manager, I want to manage employee leave requests so that I can plan team capacity.
That is far too large. Applying the patterns:
- As an employee, I can submit a leave request for a single day (workflow step, simplest case).
- As an employee, I can request a multi-day leave range (data variation).
- As a manager, I can approve or reject a request (workflow step).
- As an employee, I receive an email when my request is decided (interface/channel).
- As a manager, I can see who is away in a team calendar view (workflow step).
- As an employee, requests exceeding my balance are blocked with a clear message (rule).
- As an employee, I can cancel a pending request (workflow step).
Each slice is usable and testable. The Product Owner can decide that slices 1 and 3 together are a viable first release and defer the rest. That ability to choose is the real prize of good splitting.
Splitting in Refinement: A Practical Routine
- Pick the top items in the Product Backlog that are too large to fit in a Sprint, or that the team cannot estimate with confidence.
- Ask: "What is the smallest thing we could build that a user would value?"
- Walk through the user's journey and list the steps and variations.
- Apply SPIDR and the patterns above to find candidate splits.
- Choose splits where each slice has acceptance criteria and can be demonstrated. See Acceptance Criteria in Scrum.
- Re-estimate and re-order. Often the first slice is far cheaper than the whole.
The Scrum Master's role is to facilitate this conversation and ensure the Product Owner and Developers explore options together; see Product Backlog Refinement Explained.
Mistakes to Avoid
- Splitting by task. "Design", "Code" and "Test" are tasks, not stories.
- Splitting too far. Slices so tiny that overhead outweighs value.
- Losing the thread. Make sure the slices still serve the Sprint Goal and the Product Goal.
- Ignoring dependencies. If slice 3 cannot ship without slice 5, reconsider the split.
- Split vertically so each slice delivers visible value.
- SPIDR (Spikes, Paths, Interfaces, Data, Rules) is a practical checklist.
- Small slices improve flow, predictability and feedback.
- Use refinement sessions to practise splitting as a team skill.