Action Items That Actually Happen
Somewhere in your wiki, or a shared document, or the minutes of a meeting nobody can find any more, there is a list. It was written after an incident, by capable people, with real conviction: improve monitoring, update the docs, look into the failover. Everyone nodded. Then the list was never opened again. Six months later a familiar incident arrived and the same capable people wrote a familiar list. I have written that list. I have also, on a bad afternoon, written it twice.
A post-incident review that produces findings is half a machine. The other half is the system that turns findings into shipped changes. The review only earns back its meeting time when the actions land. The failure is not laziness, and the fix does not need discipline heroics or an enterprise project office. Action items die for four specific, boring, fixable reasons, and they live when each one has five specific parts and one recurring moment of attention a week.
This guide covers the anatomy of an action that can happen and the sizing rule that stops reviews spawning fantasy projects. It covers the follow-through machinery for a small team, and where incident actions land in your monitoring and documentation. And it covers the two or three numbers that tell you whether the loop is working. There is a worked six-week example at the end, plus the cards to run it yourself.
In this guide
- Why action items rot
- The anatomy of an action that can happen
- Five vague actions, rewritten
- Size them small: the two-lane rule
- The follow-through machinery
- Where the fixes land
- The numbers that keep it honest
- A worked follow-through
- The cards
Why action items rot
Autopsy any dead action list and you find the same four deficiencies, usually all at once. Vague wording: "improve monitoring" is a wish, not a task. Nobody can start it, so nobody does. And worse, nobody can ever say it is finished. No owner: an action assigned to "the team" is assigned to the gap between people. Everyone's job is no one's job. And each person reasonably assumes someone else has it. No date: an action without a date loses every scheduling contest forever, because it is competing against tickets that do have dates. It always will be less urgent than something. No follow-up moment: even a well-written action dies if there is no recurring point in time where somebody will notice it is not done. Attention, not intention, is the scarce resource — and a list nobody is scheduled to look at is a list that does not exist.
Before building the fix, do one humbling exercise: the graveyard audit. Dig up your last few incident write-ups — however informal — and check each stated follow-up against reality. Was it done? Half-done? Never started? Most teams find their historical completion rate is far worse than anyone guessed. Those teams find that at least one finding from the graveyard describes an incident that then happened again. Do not skip this. Ten minutes with the graveyard converts "we should be better about follow-up" from a platitude into a slightly queasy feeling. The queasy feeling is what gets the system below actually adopted.
At Northgate Retail a till-network outage produced a review with seven action items, written into a shared document called "Incident Actions - FINAL." Nobody was named on any of them, and the only date in the document was the date of the meeting. Nine months later the till network went down the same way. The new review's graveyard audit found the old document by searching for the word "till." Its edit history showed it had been opened twice: once to write it, and once by the person doing the audit. Three of the seven items were copied, unchanged, into the new list, this time with names and dates on them.
The anatomy of an action that can happen
A viable action item has five parts, and it is not viable until it has all five:
VERB + specific deliverable + owner + date + done-looks-like "Add up/down and error-rate checks for the standby path on both core switches — Sam — by Friday the 15th — done when pulling the standby cable in a test fires the alert."
Each part is doing a job. The verb forces a task instead of a topic — add, rewrite, move, schedule, test. The specific deliverable means the owner can start without a clarifying meeting. The owner is one named human — not a team, not a pair. A second person can help, but exactly one name is on the hook. The date puts it into the schedule where real work lives. And done-looks-like — the most skipped and most valuable part — defines the observable test of completion in advance. That does two things at once. It prevents the quiet downgrade where "add checks and test them" shrinks to "checks added, probably fine." And it makes closure a fact instead of a feeling. If you cannot write the done-looks-like, you do not understand the action well enough to assign it yet.
Two practical notes on the parts. Owners volunteer or are asked — in the room, out loud. The date comes from the owner, not the facilitator. That is because a date someone stated is a commitment and a date someone was handed is background radiation. And beware the end-of-review energy trap. Minute forty-three of a good review feels like anything is possible. That is precisely when a team commits to more than it will do. Write the actions while the energy is high; sanity-check the dates the next morning, when calendars are visible and the adrenaline has filed itself away.
Five vague actions, rewritten
The formula is easiest to absorb by watching it applied. Here are five action items as they usually arrive, rewritten into ones that can happen:
| As written in the review | Rewritten so it can happen |
|---|---|
| "Improve monitoring" | Add up/down + error checks to the standby-path ports on both core switches — Sam — by the 15th — done when a pulled cable fires the alert in a test. |
| "Fix the alert noise" | Move the five chattiest non-actionable alerts out of the on-call channel into a daily digest — Priya — by end of month — done when the on-call channel goes one full week carrying only alerts someone acted on. |
| "Update the documentation" | Rewrite the failover runbook against the current topology — Alex — by the 22nd — done when a teammate who was not involved walks the procedure in a tabletop test without getting stuck. |
| "Be more careful with changes" | Add "update affected runbooks and monitoring checks" as a required line on the change template — Jo — this week — done when the next two change tickets show the line completed. |
| "Look into the backup issue" | Reproduce the failed restore of the finance share and document the fix — Sam — by the 10th — done when a test restore of that share succeeds end to end. |
Notice what the rewrites did to accountability — and what they did not do. Nobody got blamed; the incident analysis that produced these findings was blameless all the way down (see blameless reviews). But the fixes have names on them, dates on them, and tests on them. Blameless about the past, ruthlessly specific about the future: that combination is the culture you are aiming for.
Size them small: the two-lane rule
The second discipline is sizing, and it exists because reviews have a tendency to prescribe surgery when they are only authorized to prescribe first aid. A review action item should be days of work, not quarters — something one owner can genuinely finish inside a few weeks alongside their real job. When a finding is bigger than that, writing it as an action item is a polite fiction. Examples include "we need a redundant path into the server room," or "the alerting design needs an overhaul." That oversized action will blow every date, clog the follow-up list, and teach everyone that incident actions are decorative.
Instead, run a two-lane split at the end of every review. Lane one: quick fixes, written with the five-part anatomy, into the queue now. Lane two: project candidates — findings that deserve real planning, budget, or design work. A project candidate's action item is honest and small: "write the one-page case for a redundant server-room path, with this incident as evidence — owner — date." The decision about actually doing the project belongs to your normal planning rhythm, where it can be weighed against everything else. (The Building a Monitoring Strategy guides cover running that kind of roadmap conversation.) The review's job is to feed the planning process good candidates with receipts — not to commit the team's next quarter in minute forty-three of a meeting.
The follow-through machinery
Well-written, well-sized actions still need somewhere to live and a moment of recurring attention. The machinery is four small habits.
Actions live where work lives
Whatever system your team actually works from, incident actions go there. That might be the ticket queue, the task board, even a disciplined shared list. Put the actions there, tagged as incident follow-ups, the moment the review ends. Not in the review document; the review document gets links to them. The reasoning is blunt: a separate "incident actions list" is a second system. Second systems require someone to remember to look at them, and remembering is exactly what fails. One queue, one place where work is picked up, incident fixes competing there openly — with their incident story attached, which turns out to be excellent ammunition in prioritization arguments.
The weekly two minutes
Put one standing line on your weekly ops meeting agenda — or your Monday checklist, if the "team" is you: "open incident actions." Two minutes: read the open ones aloud, ask each owner "on track for the date?", renegotiate honestly if not. That is the entire ceremony, and it is the part most teams are missing — the recurring moment where not-done gets noticed by a human. It is the only meeting I know that gets shorter as it gets more useful. It slots naturally beside the other small weekly rituals that keep a monitoring practice healthy, like the weekly alert review. They use the same muscle, the same fifteen-minute meeting, and adjacent agenda lines.
The aging alarm
Make overdue impossible to miss mechanically: a saved query or board filter for "incident-tagged, past date, still open," checked in that same weekly moment. An action slipping its date once is scheduling; an action aging quietly for six weeks is the graveyard forming again. The point of surfacing age automatically is that nobody has to play the nag. The list does it, impersonally, which keeps the weekly moment friendly.
Closed by demonstration, not declaration
An action closes when its done-looks-like is demonstrated. The cable is actually pulled and the alert actually received, or the restore actually run. Or the tabletop is actually walked (the procedure talked through step by step, without touching anything). An action never closes by the owner declaring it probably fine. This sounds fussy and takes minutes, and it is the difference between fixed and believed-fixed — a distinction incidents are ruthless about exposing. It also produces a pleasant side effect: small, visible proof that the system now catches what it once missed, which is worth showing the team (and the boss).
Tip: cap open incident actions per person at two or three. If a review would push someone over the cap, either the new actions wait, get a different owner, or an old one gets consciously renegotiated. A cap feels bureaucratic until you notice what it prevents: the heroic teammate with eleven open actions, all stalled, all technically owned.
Where the fixes land
Incident actions are not a random scatter; they land in four places, and each has its own feedback loop worth wiring deliberately. Monitoring changes are the most common: a new check, a corrected threshold, a rerouted alert. Feed threshold changes through whatever tuning register you keep, so the incident-driven change is recorded with its reason and revisited like any other. The threshold review ritual is built for exactly this. Runbook edits are the second big destination: the ambiguous step rewritten, the old topology corrected. Incidents are the primary quality-assurance mechanism runbooks ever get. That is a loop the Runbooks guides treat as a first-class feature. Process and documentation fixes are third: the change-template line, the coverage-review calendar entry, the contact sheet updated. And fourth, rarest and largest, the hardware and architecture asks — the redundant path, the second circuit — which travel as project candidates carrying incident receipts. File those receipts where the money conversation happens. The same uptime evidence file that holds your availability numbers is where "this outage cost us a morning, and here is the fix's price tag" becomes a fundable sentence.
The numbers that keep it honest
Three measurements, each cheap, keep the whole loop from quietly regressing. Completion rate: of the incident actions opened each quarter, what fraction closed? Perfection is not the target — renegotiating an action openly is legitimate — but a sagging rate is the earliest warning that the machinery is slipping. Median days to close: tracks whether "by the 15th" means anything; if the median stretches quarter over quarter, dates are becoming fiction again. And the ultimate metric, the one the whole pillar answers to: the repeat-incident test. Same cause, second incident — that is the actions system failing, whatever the other numbers say. When it happens (it will), treat the repeat itself as a finding in the new review. Which old action would have prevented this, and why did it not land?
Balance the accounting with celebration, visibly. Once a quarter, publish the list — to the team, and upward — of incident-driven fixes that shipped: the checks added, the runbooks corrected, the trap defaults removed. It is honest morale (the team can see the sawdust turning into furniture). It is quiet marketing for the review process itself. And it completes the promise blameless reviews make: telling the truth here visibly makes the systems better.
A worked follow-through
Take the review of a switch outage — the one analyzed in contributing causes and the five whys — which ended with six findings. The two-lane split sends four into the queue as quick fixes and two off as project candidates. Those candidates are the single-path architecture (a budget case) and the full alert-noise overhaul (a planning conversation). Here is the six-week lifecycle of the four actions, as the weekly two-minutes saw it:
| Week | What the follow-up moment recorded |
|---|---|
| 1 | Four actions ticketed with owners and dates. Standby-path checks added; closed by demonstration — cable pulled in a quiet window, alert received. |
| 2 | Critical-alert route built, separate from the noisy channel. Closed after a test alert paged through it end to end. |
| 3 | Change-template line added; marked "closing next week" pending proof on a real change. Runbook rewrite running late — date renegotiated openly, one week. |
| 4 | A real switch change executes; template line held (runbook + checks updated as part of the change). Closed. Runbook rewrite done; tabletop walk booked. |
| 5 | Tabletop walked by the teammate who was not in the incident; two unclear steps found and fixed on the spot; closed. First quarterly coverage walk held — finds two more unmonitored spots, which become their own small actions. The system is now finding problems before incidents do. |
| 6 | All four closed; the two coverage-walk babies on track. Project candidate one (redundant path) enters the budget cycle carrying the incident's receipts from the evidence file. Quarterly "fixes that shipped" list drafted. |
Nothing in those six weeks required more than the weekly two minutes plus the work itself. And note the compounding moment in week five, where a fix designed for one incident (the coverage walk) started preventing different ones. That is what a working actions loop feels like: slightly boring, quietly compounding.
The cards
The whole system fits on two cards. The action-writing card, applied to every action before the review ends:
| Part | Test |
|---|---|
| Verb + deliverable | Could the owner start tomorrow without a clarifying meeting? |
| Owner | Exactly one human name? |
| Date | Real and negotiated, not decorative? |
| Done-looks-like | An observable demonstration, written in advance? |
| Size | Days of work? If not — project candidate lane, with a small "write the case" action instead. |
And the follow-through checklist for the system around them:
| Habit | Cadence |
|---|---|
| Actions into the real work queue, tagged, review doc links them | At review close |
| "Open incident actions" agenda line — read, ask, renegotiate | Weekly, two minutes |
| Overdue filter checked (aging alarm) | Same weekly moment |
| Close only on demonstrated done-looks-like | Per action |
| Completion rate, median days-to-close, repeat-incident check | Quarterly |
| "Incident-driven fixes that shipped" published | Quarterly |
Where to go next
Actions are the last stage of the review pipeline, and they are only as good as what flows in. That includes an honest sequence of events from timeline reconstruction. It includes findings worth acting on from the cause analysis. And it includes a meeting where the truth surfaces at all, which is the blameless review. For small incidents, the fifteen-minute mini-review runs the same actions discipline at one-tenth scale: zero or one action, written properly. The full pipeline lives in Post-Incident Reviews. The list in the wiki was never the problem. Nobody opening it was.
Put this into practice with SysPeep Monitor
A large share of incident actions end up being monitoring work — add the check, fix the threshold, reroute the alert. SysPeep Monitor makes that lane fast. It provides auto-discovered devices and interfaces, plus thresholds and dependency-aware alert rules you can adjust in minutes from one web console. It provides email and other notification channels for the "done when the test alert arrives" proof. The free trial installs on any Windows machine.
Download Free TrialLearn About SysPeep