When something breaks at work, you really have two ways to respond. You can treat it as a standalone event and get on with your day, or you can treat it as one more entry in a series and look at the series. Both responses are reasonable in the right place, and both are costly in the wrong one. This comparison walks through how they differ in speed, cost, learning and team mood, so you can pick deliberately instead of by habit.
Response A: handle it as a one-off
The one-off response is fast and focused. Something fails, you find the visible cause, you repair it, you check that service is back, and you move on. Little paperwork, little discussion. For genuinely rare events, such as a power cut at a hosting site or a mistaken click that will not be repeated, this is exactly right. Spending a week analysing a unique accident wastes time that could go to real work.
The strength of this response is its low overhead. The weakness is that it quietly assumes the event is unique, and it never tests that assumption. If the same kind of problem returns, the one-off response pays the same repair cost every time, and since each repair is small, nobody notices the total.
Response B: treat it as a possible pattern
The pattern response adds one small step to the repair: log the incident in a common format and tag it with a category. Nothing else changes in the moment. The difference shows later, when you look across the log and see which categories are growing. A category that reaches three or more entries gets a short investigation into what the entries share, followed by a fix aimed at that shared condition.
The strength of this response is leverage: one fix can eliminate many future repairs. The weakness is discipline. The log must be kept consistently, and someone has to look at it. Without that, Response B degrades into a graveyard of unread notes.
Side-by-side: speed
On the day of the incident, Response A is slightly faster, because it skips the logging. The difference is typically a couple of minutes. Over a quarter, though, Response B tends to be faster overall for any team with recurring problems, because it cuts the number of repairs. Think of two people with a dripping tap. One wipes the floor every morning, quickly. The other spends an hour once to replace the washer. By the end of the month the second person is far ahead.
Side-by-side: cost
Response A has almost no upfront cost and a steady running cost that never appears on any budget line, because it is spread across many small interruptions. Response B has a small recurring cost (the logging and the periodic review) and occasionally a larger one-time cost (the fix). The comparison favours B whenever incidents recur and A whenever they truly do not. The only way to know which world you are in is to count, which is what B does and A does not.
Side-by-side: learning
Response A teaches individuals about the specific thing that broke. That knowledge stays in their heads and leaves when they do. Response B teaches the team about what keeps happening and writes it down in a place anyone can read. New members inherit the pattern list on day one. For organisations aiming to change how they work together, not just which tools they use, this difference matters a great deal, and it connects with the themes in an article about steering the human side of change when a company adopts DevOps ways of working.
Side-by-side: team mood
Repeated firefighting is draining. Response A, applied to recurring trouble, produces a feeling of Groundhog Day, and people begin to joke grimly about it. Response B swaps that feeling for a sense of progress: categories shrink, the same page stops arriving at midnight, and the team can see evidence of improvement. That change in mood is not a soft benefit. Tired teams make more mistakes, which creates more incidents, which makes teams more tired.
There is a second mood effect, on people outside the team. Customers and colleagues rarely mind an occasional failure; they mind seeing the same failure again. The link between repeated problems and perceived quality is explored in a piece on how delivery habits shape customer satisfaction, and it is a good reminder that recurrence is visible from the outside, even when it is invisible from within.
The same build failure, handled both ways
Take a concrete case: a nightly build fails because a test depends on a clock setting. Response A fixes the test and moves on. Response B fixes the test, then writes one line in the log tagged “environment difference”. Two months later, a deployment script fails because a server sits in a different time zone, and a report fails because a database uses another date format. Under Response A, these look like three unrelated stories handled by three people. Under Response B, the same tag sits on all three rows, and the shared condition jumps out: the systems disagree about time. One agreed standard for time handling replaces a long run of separate repairs.
Nothing about the individual fixes was wrong. What the pattern response added was a place for the three fixes to meet.
When Response A is the better choice
It would be dishonest to pretend B always wins. Choose the one-off response when the cause is external and singular, when the cost of the incident is trivial, or when your system is so new that you have no history to count. Choose it, too, during a live emergency, where logging can wait until the fire is out. The pattern response is not meant to slow down the first hour of any incident.
Also bear in mind that categories require volume. A team that sees two incidents a year will not find patterns in a spreadsheet; they will find them in conversation. Match the tool to the size of the problem.
When Response B is the better choice
Choose the pattern response whenever the phrase “oh, this again” is heard even once. That phrase is the clearest field signal that you may be paying repeatedly for one cause. Choose it for any system that changes often, because frequent change generates repeated kinds of failure. And choose it when different people are handling the incidents, since the person who sees the third occurrence is often not the person who saw the first.
A hybrid that works for most teams
You do not have to choose forever. A workable hybrid: respond to every incident the quick, one-off way, then add a thirty-second logging step afterwards. Review the log on a fixed schedule, such as the first Monday of the month. Escalate to the pattern response only for categories that cross your threshold. This keeps the speed of A in the moment and the leverage of B over time.
For engineers wanting reading material on the wider craft, a hub for software people that labels itself open, with a menu running from study tracks and lab work to definitions and tool listings makes a handy bookmark, though the hybrid above requires nothing beyond a shared sheet and a calendar reminder. Keep the sheet short enough that people actually open it; a bloated log is a log nobody reads.
Looking ahead
As systems become more automated, the number of small incidents tends to grow, because there are more moving parts to disagree with each other. Teams that can recognise repeats will be better placed than teams that can only repair individual faults. A broader view of where the field is heading appears in a forward-looking essay on where DevOps practice is headed at home and abroad, and the common thread through nearly every forecast is more systems, more interactions and more reason to count.
A quick decision guide
Ask yourself three questions after the next incident. Has anything like this happened before? Will it plausibly happen again? Would a fix at the shared cause be cheaper than repeating the repair? Should any reply be “yes” or “not sure”, log it and tag it. If all three answers are a firm “no”, move on without guilt. The log costs thirty seconds, and the occasional entry that turns out to be a one-off is a very small price for catching the ones that were not.









