A Beginner’s Primer on Near Misses, With a Mini-Glossary

A Beginner’s Primer on Near Misses, With a Mini-Glossary

On the third week of a first job in IT support, a trainee was told to copy a small configuration change from a test server to the live one. The trainee typed the command, hovered above the Enter key, and noticed that the clipboard still held yesterday’s version of the file. Out it went; the right text went in; work resumed. Mentioning it to the supervisor the next morning, braced for a lecture, brought only a smile and four words: “Good. Write that down.” What follows explains that reply, and finishes with a mini lexicon so the vocabulary holds no surprises when you first meet it in a meeting.

Why a beginner should care about near misses

When you are new, mistakes feel like personal failings. Every slip seems to prove that you do not belong. The surprising truth is that experienced engineers make the same slips, and the good ones have stopped being embarrassed about them. What they have learned instead is to treat the slip that did no harm as a gift: it shows exactly where the process is fragile, and it costs nothing.

A near miss is also the safest classroom you will ever get. A real outage teaches under pressure, with colleagues watching. A near miss teaches in private, at your own pace, with the full story still in your head. If you are learning DevOps or any operations skill, collecting these small lessons early can save you a great deal of stress later.

Back to the trainee: what the note said

The trainee wrote three sentences. “I was about to paste an older configuration into the live server. I noticed because the first line looked unfamiliar. I cleared the clipboard and pasted again.” The supervisor read it and asked a single question: “What would have stopped this if you had not looked?” After a pause came the answer: “Nothing.” That honest answer led to the fix, a habit of reading the first and last line of any pasted text and a team rule that live changes are made only with the change description open beside the terminal.

Notice what the note did not contain. It did not blame the clipboard, the server or the trainee. It recorded what happened and what, if anything, was guarding against it.

Five habits a beginner can start this week

  1. Keep a scrap file. Any time something nearly goes wrong, add one line, whether in a notes app or on paper.
  2. Say what really caught it. If the answer is “I happened to notice”, mark that line, because luck is not a safeguard.
  3. Change one small thing. A clearer file name, a pause before pressing Enter, an extra confirmation.
  4. Tell someone. Sharing the note with a colleague or mentor turns a private scare into a team lesson.
  5. Look back monthly. Read the scrap file and look for repeated causes.

If you are building skills through projects, the guide to practical starter projects for new DevOps learners is a good place to find safe material to practise on. Every project you build is a chance to notice your own close calls in a setting where nothing real is at stake.

Thinking clearly when something nearly breaks

The first few times it happens, the heart-pounding feeling can crowd out the thinking. A useful trick is to ask three questions in order: what was I trying to do, what did I see, and what would have happened if I had not noticed? The third question is the one that reveals the size of the lesson. Over time you will find that the habit of asking it becomes automatic. For more on building that kind of analytical muscle, the article on developing critical thinking for operations problems goes deeper.

Mini-glossary for the nervous newcomer

  • Near miss: any slip or fault stopped before harm was done.
  • Blameless: a way of discussing events that focuses on steps and systems, not on who made the slip.
  • Root cause: the deepest thing you can change that would have prevented the problem, as opposed to the first thing you notice.
  • Safeguard: any check that exists on purpose to catch an error, such as an approval step, a confirmation prompt or a second reader.
  • Staging: a practice twin of a live system, where updates are tried out first.
  • Rollback: undoing a change to return to the previous working state.
  • Handover: the moment when work or responsibility passes from one person or shift to another, and a favourite hiding place for dropped assumptions.
  • Retrospective: a short meeting held to look back on what happened and agree on changes.

You will hear these words constantly. Having a plain meaning in your head for each one makes meetings far less intimidating.

A second small story: the wrong ticket

Here is another example from the same team. A newcomer was asked to close a batch of resolved support tickets. Halfway through the list, the newcomer realised that one of the tickets was still open, with the customer waiting on a reply. Closing it would have silenced the customer’s thread. It was caught because the status column had a different colour that the newcomer happened to notice.

The team did not tell the newcomer to look harder. Their question was which part of the screen invited the error. The answer: the bulk-close screen displayed all tickets in one list, with no obvious marker for ones awaiting a customer. The fix was a filter that hides any ticket with an unanswered customer message. A beginner can learn a lot from stories like this one, because they show that most slips come from the layout of the work and not from the character of the worker.

How to practise noticing

Attention can be trained, and it sharpens through deliberate repetition. When you finish a task, spend half a minute asking: was there a moment where I almost did something differently? Even if the answer is no most days, the question trains your attention. On the days the answer is yes, write one line. After a couple of months, a short record will exist of your own habits, and that record beats any off-the-shelf checklist.

Where to read more

When you want to see how people in the wider operations world write about reliability and learning from small failures, SRE School is one site to browse; it presents a blog-style site on site reliability engineering, its home page showing recent articles. You will not understand every post as a beginner, and that is fine. Reading a little at a time exposes you to the way practitioners talk, which is half the battle in a new field.

Common beginner worries

“Will my manager think less of me?” In a healthy team, reporting a close call earns respect. If your workplace punishes it, that is useful information about the workplace, not about you.

“What if I have nothing to report?” Look again. Anything you caught late, any time you said “oh, glad I checked”, counts. The trainee’s clipboard moment felt trivial, yet it taught the whole team something.

“Do I need special tools?” No. A text file is fine.

“How long should a note take?” Two minutes for most. If it takes longer, you are probably writing about more than one event.

What the trainee did next

The habit stuck. By the end of that first year the trainee’s scrap file held a few dozen lines, and when the time came to help onboard the next newcomer, it became a short guide: the five most common slips on the team and the small fix for each. The supervisor passed it to other teams. None of it required genius. It required noticing, writing three sentences, and being willing to say “this nearly went wrong” out loud.

If one idea stays with you, let it be that supervisor’s reply: “Good. Write that down.” A close call is the cheapest teacher you will meet in your career, and it only works if somebody listens. Start your own scrap file today, keep it short, and let the small lessons add up.