Sprint Retrospective Templates: Five That Work
Updated: Oct 18
Most teams know the pattern. The same three action items roll over for the sixth sprint in a row: "improve test coverage", "tighten up PR review", "fix the flaky pipeline". Everyone nods, nothing moves, and the team fills in the same Start/Stop/Continue board it filled in last time.
The usual advice is to rotate formats, and formats do matter: different ones surface different things. But a retrospective rarely fails during the meeting. It fails afterwards, when the actions don't close. So this guide starts there, with an audit of what your retros have actually produced. Then it covers the structure under every good retro, five formats and the problem each one suits, how to write actions that close, and what to do when a theme keeps coming back. Each section ends with a test.
Audit your last six retros before changing anything
Retrospectives usually run on what people remember from the last two weeks. Christoph Matthies and Franziska Dobrigkeit reviewed common retrospective activities and found that most rely on team members' experiences and neglect existing project data. Your retro history is data of exactly that kind, and almost nobody looks at it.
A running example (composite, figures illustrative). A team of seven runs a retro every two weeks. Its new lead collects the action items from the last six retros, about twelve weeks' worth:
31 actions in total.
7 were done.
11 rolled over at least once.
13 quietly disappeared: nobody closed them, and nobody decided to drop them.
"Flaky pipeline" came up in five of the six retros.
Reading the 24 that didn't close, three patterns stand out. Most were vague ("improve test coverage"), so nobody could say when they were done. Several needed someone outside the team, such as a change to the shared CI platform. And none had any time set aside in the sprint, so they competed with feature work and lost.
The team didn't need a new format. It needed fewer, smaller actions with time allocated, a different route for the problems it couldn't solve alone, and one session that went deep on the flaky pipeline instead of mentioning it again.
The test: list every action item from your last six retros. For each one, mark it done, rolled over, or disappeared. If fewer than half got done, fix how you decide and follow up on actions before you change the format.
The structure under every format
Esther Derby and Diana Larsen's Agile Retrospectives describes five phases, and every format below is a way of running the middle of them:
Set the stage. State the goal and make it safe to be honest.
Gather data. Build a shared picture of what happened, using records as well as memory.
Generate insights. Ask why things happened, not just what.
Decide what to do. Pick a small number of actions.
Close. Confirm owners, and note how to make the next retro better.
Formats mostly differ in phases 2 and 3. Phases 1, 4 and 5 are where most retros go wrong.
For setting the stage, many teams read Norm Kerth's Retrospective Prime Directive aloud: "Regardless of what we discover, we understand and truly believe that everyone did the best job they could, given what they knew at the time, their skills and abilities, the resources available, and the situation at hand." Whether or not you read it, the point stands: the retro looks at the system, not at who to blame. A retro the manager uses to judge individuals stops getting honest input.
The Scrum Guide sets the purpose as planning "ways to increase quality and effectiveness". It suggests the most impactful improvements "may even be added to the Sprint Backlog for the next Sprint". That one idea fixes much of the closure problem: an action in the sprint backlog gets time, and an action in the retro notes usually doesn't.
Here's a template for a one-page record:
SPRINT RETRO: Sprint <n>, <date>
Format: <Start/Stop/Continue | Glad/Sad/Mad | Four L's | Sailboat | Five Whys>
Last retro's actions (review first)
<action> owner: <name> status: done / rolled over (why?) / dropped (decided)
Data brought in
Sprint goal met? <yes/no> · Carried-over tickets: <n> · Incidents: <n>
Recurring theme count: <theme> appeared in <n> of last 6 retros
What we noticed (from the format)
-
Why (insights)
-
Actions (max 3; each passes the check below; each added to the sprint backlog)
1. <action> owner: <name> due: <date> done when: <observable result>
Outside our control (escalate, don't repeat)
<issue> taken to: <name> by: <date>
The test: check whether your last retro did all five phases, and in particular whether it started by reviewing the previous retro's actions. If it didn't, start there next time. A team that never checks its last actions has no reason to believe its new ones will happen.
Pick the format for the problem you have
Rotating formats every few sprints helps people stay engaged. Choosing a format for the problem in front of you helps more:
Format | The columns | Use it when | It fails when |
Start / Stop / Continue | Start doing, stop doing, keep doing | The team is healthy and you want a quick, low-effort check | The team is stuck. It doesn't dig deep enough to find out why |
Glad / Sad / Mad | What pleased, disappointed and frustrated people | There's tension in the team that a process-only format won't surface | The team avoids conflict. Try "concerned" instead of "mad" |
Four L's | Liked, learned, lacked, longed for | A monthly or quarterly look back, where "learned" captures knowledge that would otherwise be lost | The sprint was short and there isn't enough material for four columns |
Sailboat | Wind (helps), anchor (holds back), rocks (risks), and a sun or island for the goal | The team needs to reconnect with a longer-term goal, or the usual formats feel stale | People find the metaphor gimmicky, or a remote team has no shared whiteboard |
Five Whys on one theme | One issue, followed through a chain of causes | One significant problem, or a theme that keeps coming back | Nothing stands out. Don't invent a topic |
Whatever the format, use silent writing first: three to five minutes where everyone writes on their own before anyone speaks. Then group the notes, and dot-vote on which themes to discuss. Otherwise the first and loudest voices set the agenda. An anonymous survey the day before does the same job for people who won't raise something in the room.
The test: before the next retro, write down in one sentence the problem you most want it to deal with. Then pick the format from the table. If you can't name a problem, Start/Stop/Continue with silent writing is fine.
Write actions that someone else could check
Most actions fail the same simple check: on the due date, could someone who wasn't in the room tell whether it's done? "Improve test coverage" fails. "Add tests for the three payment-retry paths that have no coverage, by Friday the 14th, owner Sam" passes.
Run every proposed action through four questions:
Is the result observable? It needs a "done when" that someone else could check.
Is it inside the team's control? If not, it belongs in the escalation box, with a name and a date. It doesn't belong in the action list, where it will roll over forever.
Does it fit the next sprint? If not, cut it down to a first step that does.
Does it have time allocated? Put it in the sprint backlog, as the Scrum Guide suggests, sized like any other work.
Keep it to three at most. In the composite team, the lead capped actions at three and applied the four questions. Over the next six retros the team agreed 14 actions and closed 11. That came from writing better actions, not from holding better meetings.
The test: apply the four questions to your current open actions. Rewrite or drop anything that fails, and record the drops as decisions. An action dropped on purpose is better than one left open and forgotten.
Five Whys without stopping at "we didn't realise"
Five Whys is the format teams most often stop too early. Here's a typical chain after a failed deploy:
Why did the deploy fail? The migration locked the orders table.
Why did it lock the table? It added a non-nullable column with a default to a large table.
Why didn't review catch it? Nothing in review checks for that pattern.
Why not? Nobody knew the pattern was risky.
"Nobody knew" feels like the end, but it's an observation, not a cause you can act on. Push on until you reach something the team can change:
Add a lint rule that flags non-nullable columns with defaults on large tables.
Require schema migrations to have a second reviewer from the team that owns the database.
Each of those passes the four questions.
Two cautions. First, Five Whys follows one chain, and real failures often have several causes. Here, a separate chain is "why did it take 20 minutes to notice?", which leads to monitoring. When there's more than one chain, ask why at each fork. For a significant incident, use a full postmortem instead. Second, if the chain ends at a person ("because Alex didn't check"), ask why the system made it easy not to check. That's the Prime Directive in practice.
The test: take the last root cause your team wrote down. If it's "we didn't realise", "human error" or a person's name, ask two more whys until you reach something a lint rule, a review step, a test or a runbook could prevent.
When the same theme keeps coming back
A theme that appears in retro after retro is telling you one of three things:
The action was too vague to close. Rewrite it with the four questions.
The fix is outside the team's control. Stop discussing it in the retro. Take it to whoever owns it, with the evidence: "this has come up in five of the last six retros, and here's what it cost".
Nobody has looked at it properly. Give it a whole session with Five Whys, and bring the data.
In the composite team, the flaky pipeline got a dedicated retro. The team brought three months of CI failure records and found that three tests caused most of the failures. It quarantined them, gave each an owner, and the theme stopped appearing.
The same logic tells you when to skip a retro. If the sprint was quiet and every open action is on track, a short check of the actions is enough. If an incident needs reviewing, hold the incident review instead. A retro exists to produce improvements. Holding one every two weeks doesn't, by itself, produce any.
The test: count how many of your last six retros mentioned each recurring theme. Any theme in three or more gets one of the three treatments above at your next retro.

What to do this week
List the action items from your last six retros and mark each one done, rolled over or disappeared. Run your open actions through the four questions, and move anything outside your control into an escalation list with a name and a date. At the next retro, start by reviewing the last actions. Pick the format for the problem you most want to solve, and add the agreed actions to the sprint backlog. The Engineering Templates & Playbooks guide has the rest of the template set.
Final takeaway
A retrospective is judged by what changes afterwards, not by how good the conversation felt. So start from your own record: how many actions closed, and which themes keep returning. Run all five phases, pick the format for the problem, and write no more than three actions that someone outside the room could check, each with time in the next sprint. Send what the team can't fix to the person who can, and give recurring themes a proper look instead of another mention.
Sources
Matthies, C. and Dobrigkeit, F., "Experience vs Data: A Case for More Data-informed Retrospective Activities", Lecture Notes in Business Information Processing (Springer, 2021), pp. 130–144: most retrospective activities rely on team members' experiences and neglect project data. https://arxiv.org/abs/2101.01528
Derby, E. and Larsen, D., Agile Retrospectives: Making Good Teams Great (Pragmatic Bookshelf, 2006): the five phases (set the stage, gather data, generate insights, decide what to do, close the retrospective). https://pragprog.com/titles/dlret/agile-retrospectives/
Kerth, N., Project Retrospectives: A Handbook for Team Reviews (Dorset House, 2001): the Retrospective Prime Directive, as quoted in Martin Fowler, "Priming Prime Directive" (2012). https://martinfowler.com/bliki/PrimingPrimeDirective.html
Schwaber, K. and Sutherland, J., The Scrum Guide (November 2020), "Sprint Retrospective": purpose; timebox of up to three hours for a one-month sprint; improvements may be added to the next Sprint Backlog. https://scrumguides.org/scrum-guide.html
Related reading
Part of the Engineering Templates & Playbooks guide: ShiftQuality's collection of ready-to-adapt templates.


