I delay on purpose

Some people see an update banner and click in the same second. Some people turn on Patch Tuesday and go to lunch. Some people flash BIOS, switch, and printer firmware because the vendor email said “recommended.”

I’m not that person.

I’m an IT coordinator. I delay. I read. I analyze. And it isn’t a habit of being difficult — it’s survival instinct. Because when something breaks, Microsoft doesn’t show up at the door. Dell doesn’t. The changelog doesn’t. I do.

The life of the one who answers

People who don’t live this think coordinating IT is picking tools and watching tickets. The visible part is that. The invisible part is something else: carrying the quiet fear that a “harmless” update becomes the incident of the week.

Windows Update. Driver. Server firmware. Motherboard firmware. Access-point firmware. An antivirus patch that decides to reinvent network policy. A printer update that turns the spooler into a museum. Each of those things has a green button. Each of them can, on any given morning, turn the whole school into a hallway of people asking the same lines:

— Where’s the internet? — Why won’t the system open? — Who touched it?

Almost never did a flesh-and-blood person “touch” it on purpose. An automatic update did. Or a rushed click. Or a “we’ll look later.” The effect, though, has an owner. And the owner, in practice, is me.

Fear with a basis

I’m afraid of Windows Update. Not of the concept. Of the timing. Of the package that fixes a CVE and breaks network printing. Of the forced reboot mid-shift. Of the feature that arrives uninvited and changes the behavior users had already memorized. Of Patch Tuesday that, in theory, is routine — and in practice is a roulette wheel.

I’m afraid of firmware. Because firmware isn’t an app. Firmware is the floor. When it goes wrong, there is no “uninstall.” There is a machine that won’t boot, a switch that becomes a glowing brick, a laptop blinking with no POST, and a line of people who don’t want to hear about flash or recovery — they want to know why class stopped.

That fear isn’t superstition. It’s curriculum. It’s having seen enough to know that “recommended by the vendor” sometimes means “tested in their lab, not in your reality.”

The danger of looking modern

There is social pressure in technology: whoever delays an update looks outdated. Whoever holds a version looks afraid. Whoever asks “have you tested this in staging?” looks bureaucratic.

It’s an especially cruel trap for people who coordinate.

Because modernity without judgment becomes churn. Churn without reading becomes instability. Instability without an owner becomes chaos — and chaos always finds someone to blame. Almost never the engineer on the other side of the world who signed the release. It finds the coordinator. In the office. On WhatsApp. In the hallway. With the look of someone waiting for an explanation now.

The real danger isn’t staying on an old version forever. The danger is treating updates as an act of faith:

• Mass-apply Patch Tuesday because “it’s Tuesday.”
• Accept a major system bump without reading what breaks.
• Flash BIOS/UEFI firmware during the coffee break.
• Let Windows Update decide on its own the hour of the next emergency.
• Confuse “there is a security patch” with “I can apply everything without looking at the rest.”
• Push automatic updates in labs, offices, and classrooms as if they were the same environment.

Security matters. Of course it matters. But security without operations is just a slogan. A patch that fixes a CVE and takes down a critical service isn’t a win — it’s a problem swap. Sometimes the new problem is worse: now you’re vulnerable and offline, with thirty people at the door and zero patience for release notes.

The scene I’ve lived too many times

Picture the morning.

Monday. Lab full. Office depending on the system. Someone, last night, left Windows on “update and shut down.” Or a well-meaning tech applied firmware “so we don’t fall behind.” Or the automatic policy did what automatic policies do: acted without a witness.

In the morning, authentication fails. The printer disappears from the network. A laptop opens on a blue screen nobody asked for. Wi-Fi oscillates between miracle and silence. The line grows faster than Event Viewer.

Then comes the question I already know by heart:

— Why did this happen?

And the honest answer — the one few people like to hear — is: because updating without reading is also a decision. Just disguised as progress. And progress, when it breaks, always looks for a human face.

That face, on the org chart, is me.

Delaying isn’t stopping

Some people hear “I delay updates” and translate it as “I never update.” That isn’t it.

I update. With a method. Because coordinating IT without updating is another form of negligence — and I answer for that too.

I read what comes in. I separate the urgent from the cosmetic. I isolate the test. I have a way back. I document the why. If the update is security and the risk is real, I accelerate — eyes open, defined window, rollback thought through. If the update is “we have a new screen and a different service,” I wait for the real world to report what the release notes forgot to confess.

Patience isn’t immobility. It’s a filter. It’s the difference between managing risk and collecting incidents.

Forty years teach caution

I wasn’t born this way. I became this way.

Forty years of experience in technology didn’t make me faster on the click. They made me slower on the green button. I’ve seen too much: a system that “just updated,” a machine that never came back after the flash, a network that fell to a well-meaning patch, a furious user because the tool changed face without warning. I’ve seen people celebrate a new version on Monday and ask for rollback on Tuesday.

Experience, in my case, didn’t become bravado. It became a useful scar. It taught that the vendor recommends in their lab — and I operate in the school’s reality. It taught that novelty without reading is debt. It taught that, before the click, the right question isn’t “is it available?” It’s:

— If this goes wrong, who explains?

The answer, almost always, is me. So I read first. I delay on purpose. And I sleep a little better because of it.

I’m someone in IT with enough decades to know: whoever updates on autopilot isn’t bold — they’re the next target.

And if someone wants practical proof: this text was written on Ubuntu 22.04. Not on the latest release. Not on the blinking “upgrade available” banner. On an LTS that still works, still opens the editor, still lets me publish — while the world chases the fashionable number. When I move, it will be because I read, tested, and accepted the risk. Not because the calendar asked.