Skip to content

The Wednesday Kata: How One Team Learned to Read Error Output

Published November 11, 2026 by Beena Yadav

Sanne joined a small product team as its first dedicated operations engineer, and within a month she noticed something odd about how her new colleagues dealt with errors. When an application crashed in staging, three people would open three terminals, scroll through screens of text, and ask each other in the chat whether anyone had seen this before. Nobody was reading the message in front of them. What follows is how the team turned stack trace reading practice into a small weekly habit, and what happened to their debugging over a quarter.

The scene: a crash and a lot of scrolling

The team was good. They shipped on time, wrote tests, and liked each other. But when Joost’s service fell over one Thursday afternoon, the whole group spent forty minutes before someone noticed that the answer was in the sixth line of the error output, plainly stated. The message named the file, the function and the kind of failure. It simply sat under a pile of lines nobody had learned to skip.

Sanne did not blame anyone. She had seen the same thing at earlier jobs. Reading an error well is rarely taught; people pick it up unevenly by watching others, and many never improve beyond a rough guess at where to look.

The proposal: fifteen minutes on Wednesdays

At the next retrospective, Sanne proposed something modest. Each Wednesday after stand-up, the team would spend fifteen minutes on a single error from the past. No slides, no long discussion. She called it the Wednesday kata, borrowing the word from martial arts, where a short fixed sequence is repeated until the movements become automatic.

Some people raised eyebrows. “We debug all the time,” said Joost. “Isn’t that practice enough?” Sanne’s reply stuck with the team: “We debug all the time, and we are exactly as slow as we were last year.”

How a session ran

Sanne kept the format identical so that people could focus on the skill instead of the process.

  1. She picked an old error from the team’s own history, with the fix removed from the notes.
  2. Everyone had two minutes of silence to find three things: the line that names the failure, the first line that belongs to the team’s own code, and the single question they would ask next.
  3. People wrote their answers on paper before speaking, which stopped the loudest voice from setting everyone’s view.
  4. The group compared answers, then looked at what had actually happened.
  5. Each person noted one reading habit to try the following week.

Of all the steps, the silent writing paid off the most. It revealed that colleagues disagreed about something as basic as which line mattered, and nobody had known.

The first weeks were humbling

The early sessions did not go well, and that was the point. Joost, a developer with nearly ten years behind him, picked a line from the library code rather than from his own service three times in a row. Another colleague realised she always jumped to the bottom of the output because a former project’s tool printed the cause last. This was a habit carried over from one tool’s quirk and wrongly applied to every other.

Because feedback came within a minute, from the real answer and from peers’ honest comments, each person got a precise correction instead of a vague sense of improvement. Sanne wrote the habit list on a shared board: “Find the first line from our own code.” “Read the message in full before scrolling.” “State the cause in a sentence before opening any file.”

The objection that came up in week five

Around the fifth Wednesday, a newer colleague asked a fair question: were they getting better at reading old errors, or just better at the specific old errors in the folder? Sanne took it seriously. She started mixing in fresh failures from the previous few days, which nobody had yet studied. The results were reassuring. The reading habits carried over, because they were about method, not about memorising particular messages. She also noted that the sessions got more interesting once the material was recent, since people cared about problems still in their own sprint.

The adjustment that paid off

After a month, one habit stood out. People who stated the likely cause in a single sentence before opening any file diagnosed problems noticeably faster than those who dived straight into the code. Saying it aloud made guesses visible and testable, so wrong guesses died early rather than lingering for twenty minutes.

The team adopted it as a rule of thumb: guess in words first, then verify. It cost almost nothing and shortened the typical debugging session. It also made help requests better, since a question like “I think the configuration is missing a value, can you check?” is much easier to answer than “it crashed, any ideas?”

Widening the drill

Once reading stack traces felt more comfortable, the team added other short katas on alternate weeks. One was reading a failed deployment log and naming the first step that went wrong. Another was looking at a container that kept restarting and saying what they would check first; here they used Kubernetes events as the raw material. Each exercise kept the same bones: a narrow target, a short clock, silent answers, an honest comparison, one adjustment.

For readers wondering how such everyday skills connect to a longer professional path, the site’s guide to progressing from a junior engineer to a senior one covers what changes at each stage, and the overview of core abilities expected of engineers this year offers topics for more drills. People coming across from administrator roles can look at the piece on moving from system administration into this field.

Where an outside coach entered the picture

About six months in, Sanne wondered whether an experienced outsider might run a session or two and suggest drills the team had not thought of. A colleague mentioned that DevOpsTrainer is a searchable directory of trainers, instructors and coaches for DevOps work, so they browsed it as a starting point for the search. They kept their own Wednesday routine going regardless; an occasional visitor was a supplement, not a replacement.

What the team noticed after a quarter

Nobody measured anything fancy. Still, the changes were visible. The long scrolling sessions in the chat became rarer. New joiners were given the Wednesday sheet on their first day and picked up the reading habits within weeks. Joost, the sceptic, began running a session himself and was, according to Sanne, the strictest reviewer of anyone’s guess.

The deeper lesson was not about stack traces at all. The team had been confusing time spent with skills gained. Once they separated the two, picking a narrow target, checking it honestly and adjusting one thing, they found that fifteen minutes a week did more than a year of casual exposure.

If you try something similar, start with an error from your own history, hide the answer, give everyone two minutes of silence, and compare notes. Keep the session short, keep the target small, and write down the single habit you will change before the next one.