The urge to fix broken things is what drew most of us into IT in the first place. You understand a system well enough to see what's wrong, and sitting on that knowledge without acting on it feels almost physically uncomfortable. So you act. And a lot of the time, that instinct is exactly right.
But I have learned, through a few expensive lessons and a lot of slower, quieter ones, that knowing when not to touch something is a real skill. And the reason it doesn't get credit in this profession is simple: restraint is invisible. No one ever puts "left the working workaround in place and preserved three weeks of business continuity" in an achievements doc.
The Case for Always Fixing It
Before I argue my side, let me give the other side its due, because it's genuinely reasonable.
Technical debt compounds. A workaround that gets left in place for a month becomes the assumed foundation of a system in six months. Users adapt, processes get built on top of it, and now the fix is three times harder because you have to unwind two layers of adaptation before you can get to the original problem. The person who didn't fix it in January and left it for the August hire is not blameless.
There's also a real risk that "restraint" becomes a career-safe way to avoid hard work. If you tell yourself often enough that the blast radius is too high, you end up with a system full of things nobody is allowed to touch. That's a different kind of failure, slower and quieter, but still a failure.
So I'm not arguing for inaction as a default. I'm arguing for judgment: the specific, earned ability to tell the difference between a problem that needs fixing now and a thing that is wrong but not currently causing harm, where acting would cause more disruption than the wrongness itself.
Load-Bearing Wrongness
The clearest case is what I think of as load-bearing wrongness: a configuration, permission, or process that is technically incorrect but that everything downstream has quietly adapted to.
I've seen a mail routing rule at a company that sent a category of internal notifications to a shared inbox that wasn't monitored. By the time I found it, three departments had built their own workarounds to get the information they needed from other sources. The rule was wrong. It was also, at that point, structurally irrelevant. Fixing it correctly would have meant auditing every downstream workaround, coordinating three teams, and accepting a week of regression risk, so that the right information could flow through a channel nobody actually used anymore.
The correct answer, when I stopped feeling the itch to fix it, was to document it, leave it, and prioritize the actual gaps in monitoring that the workarounds revealed. The rule was wrong. The workarounds worked. No one was being harmed. The right move was not to act.
The question is not "is this correct?" It is "who is currently harmed by the incorrectness, and would fixing it help or harm them more?"
The Blast Radius Calculation
A permission that is technically over-privileged is a real security concern. It should be addressed. But if removing that permission today would break the daily workflow of two teams who depend on it and have no documented alternative, then "address it today" is not actually the right answer. The right answer is: plan the fix, document the risk, communicate to the stakeholders, and schedule the change with appropriate change control, testing, and a rollback plan.
What I've watched junior IT practitioners do, and I did it myself early on, is see the problem and go fix it. No change management, no stakeholder awareness, no rollback. The logic is clean: this is wrong, I know what right looks like, I'll make it right. And then the two teams who depended on the over-privileged access spend two hours unable to work, the fix gets rolled back, and the practitioner loses trust they will spend months rebuilding.
The technical judgment was correct. The operational judgment was wrong. In live systems with real users, that distinction matters enormously.
Scripts Nobody Remembers Writing
There's a specific kind of system in every organization I've worked with: a script, a scheduled task, an automation built several years ago by someone who has since left, that runs in a way nobody fully understands. It does something. The something seems useful. No one is quite sure what happens if it stops.
The instinct is to investigate, understand it fully, and either replace it properly or remove it cleanly. That's the right long-term answer. But if the investigation requires a weekend of regression testing, touching it at all introduces failure risk, and the organization has bigger fires, then the right move right now is to document what you know, add monitoring so you're alerted if it fails, and schedule the proper investigation for a time when you have the bandwidth to do it safely.
"We know this exists, we don't fully understand it, we're watching it, and we have a plan" is a legitimately good answer. It is not the same as ignoring it. The difference is in the documentation and the monitoring.
What This Looks Like in Practice
The mental shift that helped me most was changing the question I ask when I find something wrong. Instead of "can I fix this?", I ask two things: "who is being harmed by this right now?" and "what would happen if I act today versus in three weeks with proper preparation?"
If someone is actively harmed, you act. That's the emergency case and the judgment is clear. The harder cases are where the harm is theoretical or future-tense: "this could become a security issue," "this will get harder to fix," "this is building technical debt." Those are real concerns, and they deserve a response, but the response is a planned change with proper scope, not an immediate fix driven by the discomfort of leaving something wrong.
Senior IT practitioners also think more carefully about reversibility. A change that can be rolled back cleanly in five minutes has a much lower effective blast radius than one that touches live data or reconfigures a service with downstream dependencies. When in doubt, prefer the reversible path, even if it's slightly less elegant technically.
The Invisible Achievement
The frustrating thing about this skill is that it produces no artifact. When you act, you have something to show: a ticket closed, a system corrected, a problem resolved. When you hold, you have nothing except the absence of an incident that might not have happened anyway.
I've tried to get better at making restraint visible in my own documentation: noting in a runbook why a known issue was left in place, what the tradeoff was, and what conditions would change the calculus. That way, the decision to hold doesn't look like ignorance to the next person who inherits the system.
It also helps when you can point to a time you held and it was right. I've avoided two separate migration incidents by slowing down when I had the itch to move fast. Neither non-event is in my resume. Both are in my head, and they inform every change decision I make now.
I'll push back on one framing that I think leads people wrong: the idea that restraint is the same as acceptance. It isn't. Restraint is a decision to act thoughtfully rather than immediately. The documentation is part of the decision. The monitoring is part of the decision. "I know this is wrong, I've noted it, and I will address it properly when I have the runway to do it safely" is not the same as "I noticed this was wrong and left it alone." The difference is intentionality.
The organizations where I've seen the most reliable IT operations are not the ones with the fewest wrong things. They're the ones where people know which wrong things matter, have a view of which ones to address and when, and are honest about the difference between a known planned risk and an ignored one.
I'm curious where this breaks down. If you've worked somewhere where restraint became an excuse for accumulating debt, or where acting fast was always the right call, I'd genuinely like to hear it. Drop me a line or push back below.
Comments