
Picture a sticky note on a new operations engineer’s monitor that reads: “The server doesn’t care what you believe.” It looks like a joke at first. Over time it turns into the shortest possible summary of SysOps, the quiet craft of keeping individual machines healthy. Much of the damage in operations comes from comfortable beliefs, not from exotic bugs. Here are six myths that circulate in stand-ups and corridors, and what the Ops Atlas says about each.
Myth 1: “We are in the cloud, so nobody needs to administer servers”
It is a tempting thought, especially in a young company that has never owned hardware. And it is partly right: the provider looks after the data centre, the power and the physical host. But on rented virtual machines the operating system inside is still yours. The Atlas is direct about this, noting that on infrastructure-as-a-service the guest’s patches remain the customer’s responsibility. Imagine a team that finds a years-old kernel on a rented instance simply because nobody believed it was their job. The cloud moved the boundary; it did not erase it.
Myth 2: “We take snapshots, so we have backups”
A snapshot is a quick photograph of a disk, usually stored alongside the thing it photographs. It is wonderful for undoing a bad change in the next five minutes. It is not what saves you when the volume, the account or the region is gone. The Atlas puts the distinction bluntly, and its top maturity level asks for records of restores that were actually carried out. When a team says its backups are fine, there is only one question that matters: when did you last restore from them, onto a machine that was not the original?
Myth 3: “Switching SELinux off is a harmless way to unblock the app”
This one always arrives on a Friday. The deployment fails, the logs mention a denial, and somebody types the command that turns the whole protection layer off, promising to revisit it on Monday. Monday never comes. The Atlas lists disabling firewall, mandatory access control or sandboxing as an anti-pattern and describes a narrower path: leave the system enforcing and relax a single domain with a per-domain permissive flag, or switch a single profile to complain mode, then read what it records and write a proper rule. It takes ten minutes longer and spares you a much worse conversation later.
Myth 4: “When in doubt, restart it”
Plenty of us were quick with a restart once. It works often enough to feel like skill. But a restart wipes out the stack of evidence: memory contents, open connections, stuck processes, the exact state of the queue. The Atlas calls restart-first an anti-pattern for that reason. A better habit is to spend a minute capturing state with a prepared triage script and only then restart. The service comes back just as fast, and you are left with something to analyse when it fails again at three in the morning.
Myth 5: “Making the process unkillable protects the important service”
When memory runs short, Linux picks a victim. Some administrators respond by giving their favourite process the lowest possible score so it can never be chosen. The Atlas points out that this only relocates the problem: the kernel kills something else, often something the important service needs. Picture a database that survives such a setting while the monitoring agent beside it is killed instead, so the outage stays invisible for an hour. The sturdier approach is to size the memory properly, cap the greedy workload and fix the leak.
Myth 6: “Every operations team should aim for the same toil ceiling”
You will hear a fifty percent figure quoted in this context. The Atlas adds a caveat: that number is one large company’s internal target and carries no universal authority. Your ceiling depends on your estate, your staffing and your tolerance for risk. The more useful practice is to measure the share of time your team spends on repetitive manual work, watch whether it falls, and ask whether each repeated task can become a timer, a script or a baseline.
Why myths survive so long
Part of the reason is that most of them are partly true. Cloud providers do take on enormous work. Snapshots really are useful. Restarting really does clear many faults. A belief that is right seventy percent of the time gets reinforced by every success and forgiven after every failure, because the failures look like bad luck. Operations folklore also travels well through job changes: an engineer carries the rule from a previous employer, where it fit, into a new estate, where it does not.
The antidote is cheap and slightly humbling. Ask for the evidence behind a rule when it is quoted, and if nobody knows its origin, treat it as a hypothesis. Hold small reviews where one myth is checked against the actual machines. Teams that do this once a month find that the folklore thins out, and that newcomers feel allowed to question things, which is the real sign of a healthy operations culture.
What these myths have in common
Each of them swaps a measurable fact for a feeling. “It is the provider’s problem”, “we have snapshots”, “we will fix it on Monday”: none of those can be checked. The cure is the same each time. Write down what you believe, find a way to test it, and record the result. That small loop is what lifts a team from ad hoc to documented, and from documented to measured.
If you are making your own way into this field, the practical advice in a guide for moving from support and administration into DevOps fits well with this list, because a solid host-level foundation is what many of those transitions stand on. And for a longer view of how responsibilities change with seniority, see the career-path article on growing from a junior role into a senior one.
A small test you can try this week
- Pick one belief your team repeats about its servers.
- Ask: how would we know if it were false?
- Run that check on one machine and write down the answer.
- Share the result at the next stand-up, even if it is dull.
One reference worth keeping bookmarked is the Atlas page describing SysOps and its common myths, because it names the traps without drama. Whatever you read, hold on to the sticky-note rule: the server does not care what you believe, and the sooner your team tests its comfortable stories, the fewer nights it spends proving them wrong.