A user reports a problem. That does not mean they caused it.
There is an old joke in IT. When something goes wrong, the diagnosis is simple:
The problem is between the chair and the keyboard.
Usually, we mean the user. They misunderstood something, ignored a message, opened the wrong document or clicked where they should not have.
As internal humour, it can work. As a starting point for diagnosis, it is much less useful.
A user can make a mistake. But they can also follow the correct procedure and encounter a faulty system. The problem may originate in an administrator’s change, an application defect, an operating system update or a combination of circumstances.
The person sitting in front of the screen may simply be the first to discover that something is wrong.
Where a fault becomes visible is not necessarily where it originated.
First, Establish Whether the User Actually Made a Mistake
Imagine a routine support call.
“I cannot save the document.”
“What did you do?”
“The same thing I always do.”
That answer can frustrate a technician. It is too general for diagnosis. Nevertheless, it may be true.
The user opened the same application, followed the same procedure and worked with the same kind of document. This time, however, the result was different.
Perhaps permissions changed. Perhaps storage is unavailable. Perhaps the application contains a defect triggered by particular data. Or perhaps another part of the environment changed in the meantime.
The user may not know any of this. They cannot see the logs, do not know about recent changes and have no access to the server configuration.
All they know is that they cannot complete their work.
A reasonable starting question is therefore:
What exactly happened, and under what conditions?
Not a preliminary verdict:
What have you broken this time?
The user should help describe the symptoms. They should not have to prove their innocence before we investigate them.
The System Itself Can Be Wrong
When investigating a problem, I would distinguish at least three possibilities:
- A person used a functioning system incorrectly.
- A person used a faulty system correctly.
- The failure emerged from the interaction between the system, data, configuration and working procedure.
There is no reason to decide in advance which one occurred.
Imagine an application that reports success after the user presses Save but fails to write some of the data. Or a report that is generated without a technical error but contains incorrectly calculated figures.
The user may trust the result precisely because they followed the instructions and the system confirmed success.
If an accountant later discovers the discrepancy, that does not mean the accountant caused it. They may be the person who detected the defect.
From my accounting and IT perspective, this is an important distinction: successful technical execution is not enough to establish that a result is correct in business terms.
During diagnosis, I therefore want to know more than which button someone pressed. I also want to know what the system actually did afterwards.
CVE Is Not Another Name for Every Software Bug
In security discussions, we also encounter CVE identifiers. They provide a common way to identify and describe publicly disclosed cybersecurity vulnerabilities. They are not a general catalogue of every functional defect in software. See the CVE Program overview.
For this discussion, it is important not to confuse three things:
- A functional defect: the system does not do what it is supposed to do.
- A security vulnerability: a weakness with security implications.
- A security incident: an event whose actual circumstances and impact need to be investigated.
The existence of a CVE record does not, by itself, establish that a particular user or organization has been attacked. The record describes a vulnerability; assessing a specific event requires additional evidence.
Likewise, I would not expect a user to determine from a single error message whether they are seeing their own mistake, a software defect or a sign of an attack.
That requires diagnosis, knowledge of the environment and available records—not an assumption based on who called the help desk.
The User Changed Nothing. The System Changed Underneath Them
Imagine someone finishing work in the evening and allowing their computer to install updates.
The next morning, they sign in, open the same application and follow the same procedure.
This time, something does not work.
When asked, “What have you changed since yesterday?” they answer, “Nothing.”
That is not necessarily an excuse. They changed nothing. The environment they use changed.
There is a concrete historical example of why we should not automatically attribute such failures to the user. With the Windows 10 October 2018 Update, version 1809, Microsoft confirmed a file-deletion problem involving certain configurations of Known Folder Redirection. It affected circumstances in which files remained in the original folder location after redirection. This was not a universal deletion of everyone’s data; it was a specific defect in the update process. Microsoft described the cause in its October 9, 2018 update.
Microsoft paused distribution and announced the resumption of the rollout on November 13, 2018.
There is also a documented historical issue involving the preservation of settings. In KB3120677, released on November 24, 2015, for Windows 10 version 1511, Microsoft explicitly described a fix for an issue affecting users’ settings preferences. A changed setting after an update should therefore not automatically be treated as evidence that the user changed it. See Microsoft’s update notice.
I would not use these examples as an argument against updates. I would draw a different conclusion:
An updated system is not automatically a fault-free system, and correctly installing an update does not rule out a vendor defect.
When a user says, “It worked yesterday,” they may be providing an important clue about timing—not making an excuse.
The Administrator Made the Change. The User Has to Explain the Failure
Consider another illustrative example.
An administrator adjusts permissions, changes a service setting or deploys a new configuration. The change has an unintended consequence: some people lose access to their documents.
The user knows nothing about the change. They try to work the next morning and receive an access-denied message.
What follows is a password check, an application restart and questions about whether they opened the right folder.
Those checks may have their place. They should not replace the question:
What changed on the system side?
If the cause turns out to be an incorrect permission change, the user was not the source of the problem. They were the first person to encounter its consequences.
Nor would I consider “It works for your colleague” sufficient evidence against the user. Accounts, permissions, versions, devices and data may also need to be compared.
Administrators can make mistakes. Professionalism is not defending our own changes at any cost. It is being willing to investigate them as carefully as we investigate the user’s actions.
Administrators Are Users Too—With Greater Reach
In IT, the word user often means someone outside our own department.
But administrators also use interfaces, tools and accounts. The difference may be the scope of their privileges.
Imagine two open consoles. One connects to a test environment; the other connects to production. Similar names, identical colour schemes.
The command is correct. The environment is not.
We can conclude that the administrator should have paid more attention. That still does not explain why the environments were so easy to confuse or why a single action had such a large impact.
When designing the environment, I would therefore examine:
- whether production is clearly identified;
- whether elevated privileges are needed throughout the task;
- whether the scope of a change can be checked before execution;
- whether a critical operation requires an additional control;
- whether a usable rollback or recovery path exists.
The aim is not to remove personal responsibility. It is to avoid making safety depend entirely on the assumption that an expert will never make a mistake.
The User Clicked. We Still Need to Investigate the Whole Story
Of course, users can take the wrong action.
Imagine an employee expecting an invoice. They receive a fraudulent message resembling normal business correspondence and open its link.
“Clicked a malicious link” may accurately describe one step. To understand the incident, however, I would also ask:
- What would have helped the employee recognize the message?
- Could they easily verify the request?
- What happened after the click?
- Which additional controls were supposed to intervene?
- What access did the account have?
- How quickly was the event reported?
A person’s mistake and the scale of the resulting damage are two different questions.
The user may bear responsibility for their action. We still need to investigate why that action led to those particular consequences.
The Cause of a Failure and Preparedness for Its Consequences Are Different Things
The same distinction applies to a defective update or an administrator’s mistake.
I would assess these questions separately:
- What triggered the event?
- What should have detected it?
- What should have limited the damage?
- What should have enabled recovery?
A faulty update may cause data loss. An unprepared recovery process may be an additional problem. The second problem does not change the origin of the first.
Likewise, having a backup does not make an incorrect change correct. And a failed recovery does not, by itself, establish that the user caused the original failure.
Separating these questions is both fairer and more useful. It allows us to identify several weaknesses without assigning every failure to one person.
Training Is Not a Universal Fix
If someone did not know the correct procedure, training may be an appropriate response.
But if an application writes data incorrectly, training its users will not repair its code. If an administrator changed permissions, explaining the user’s password to them again will not restore access.
Before selecting a corrective action, I would distinguish between these situations:
- Knowledge was missing. Explain and practise the procedure.
- A mistake occurred. Examine the interface, working conditions and controls as well.
- The procedure was not workable. Remove the obstacle or define an approved exception.
- The system failed. Repair and verify the system.
- A rule was deliberately broken. Investigate the reason and responsibility.
The corrective action should match the established cause—not simply whatever is easiest to record in the incident report.
Accountability Without a Scapegoat
I am not arguing that users can never be responsible. Nor am I arguing that every problem is the administrator’s or vendor’s fault.
I want to avoid the opposite extreme: selecting the person to blame before diagnosis begins.
When assessing responsibility, I would consider who had which information, authority and realistic options.
Someone who ignored a clear rule should not be assessed in the same way as someone who correctly followed an approved procedure in a faulty environment.
A mistake also needs to be distinguished from deliberate misuse of access.
Accountability should follow more than the final click. It should also examine the decisions and conditions that preceded it.
Better Questions After an Incident
Instead of automatically asking, “Who broke it?” I would start with:
- What exactly happened?
- What result was expected?
- Did the user actually do anything wrong?
- What changed in the application, operating system or configuration?
- Which interventions and updates preceded the event?
- What do the available records show?
- Can we reproduce the problem?
- What limited or amplified its consequences?
- What will we change, and how will we verify that the correction works?
Personal accountability does not disappear. It gains a stronger foundation than a first impression.
Diagnosis First. Judgement Afterwards.
We can keep the old IT joke. Humour belongs at work.
It should not replace professional investigation.
Users can make mistakes. So can administrators. The product itself, or its update, can also be faulty. Sometimes several causes interact.
We should expect users to exercise reasonable care, follow procedures and cooperate with troubleshooting. We should expect IT professionals to investigate not only the user’s actions, but also the system and their own changes.
The person reporting a fault may be the very person who helped uncover it before it caused greater damage.
Yes, the problem may be between the chair and the keyboard. First, let us establish whose chair and whose keyboard—and whether the problem originated there at all.
Sometimes, the person in front of the screen broke nothing. They were simply the first to discover that someone—or something—else had.
Sources
- CVE Program — Overview
- CVE Program — Glossary
- Microsoft — Updated Version of Windows 10 October 2018 Update Released to Windows Insiders, October 9, 2018
- Microsoft — Resuming the Rollout of the Windows 10 October 2018 Update, November 13, 2018
- Microsoft Support — Cumulative Update for Windows 10 Version 1511: November 24, 2015, KB3120677