Troubleshooting Rule Number One: Don’t Forget the Basics

TLDR: The Fundamentals of Troubleshooting

• The first rule of troubleshooting is simple: always check the basics first.
• Skipping fundamentals wastes time, frustrates customers, and undermines your credibility.
• A real-world example with a WordPress plugin shows how a hidden on/off switch created weeks of unnecessary back-and-forth.
• Checklists, clear communication, and modeling good habits help IT teams avoid overlooking simple fixes.
• Pair technical competence with compassion, empathy, listening, and respect for the best results.

Read the full article just below the video.

OSI Reference Model Layer One

When I first started working with technology, one of the earliest lessons drilled into me was about troubleshooting. It was not fancy, it was not glamorous, and it certainly was not complicated. The mantra was simple: “Always start with the physical layer.”

Is it plugged in?
Is the power switched on?
Is the breaker thrown?

That was troubleshooting 101. At the time, I did not realize I was being introduced to something far bigger: the OSI reference model. For the uninitiated, the physical layer is layer one of the seven-layer model that describes how data moves across a network. And here is the thing: even my wife Janet, who does not work in tech at all, knows this golden rule of troubleshooting. She may not be able to explain subnet masks or DNS resolution, but she understands the importance of checking whether something is powered on.

And yet, even with all our training, experience, and cleverness, sometimes we forget the fundamentals.

When We Skip the Basics

If you have been in IT for any length of time, you have seen it happen. Instead of starting at the beginning, we jump into complex diagnostics. We tweak configuration files. We run traceroutes. We recompile code. All before asking the obvious question: Is it actually plugged in?

I have been guilty of it. You probably have too. And it is not because we are careless. It happens because the human brain is wired to look for patterns, especially complex ones. We want to solve puzzles. We enjoy proving that we can dive into the deepest technical weeds and come up with answers. But in doing so, we sometimes skip right past the simplest fix.

The irony is that those basic questions about power, plugs, and switches are often the fastest way to resolve a problem. Missing them wastes time, frustrates customers, and makes us look less competent than we really are.

A Real-World Example: When Reporting Went Dark

Let me share a story that happened recently with Compassionate Geek Online Training, where we host courses for IT professionals. On our site, we use a WordPress plugin called LearnDash, which provides the learning management system that powers all of our training. Normally, it works beautifully. But not long ago, the reporting functions in the site manager quit working.

Reporting is not just a “nice to have.” It is how we and our clients track learner progress, confirm course completions, and measure impact. So while this was not a show-stopping outage, it was important.

Naturally, I started with a quick audit to see what I could find. Everything looked fine. Configurations were correct. Permissions were right. Nothing obvious jumped out at me. So I did what many of us would do: I opened a support ticket with the developer.

To their credit, LearnDash usually provides excellent support. But in this case, it turned into a drawn-out process. Multiple emails over several weeks. Different technicians weighing in. Even someone from their business office got involved. And yet, no resolution.

Meanwhile, I kept poking around myself. I was not obsessed, but I was not willing to drop it either. And eventually, buried in an obscure corner of the plugin’s settings, I found it.

An on/off switch. In the “off” position.

One click. That was all it took. Suddenly, the reporting functions came back to life. Problem solved.

What Went Wrong and What Should Have Happened

Now, let us be fair. I do not think I turned that switch off. But whether I did or not does not really matter. The fact remains: if the support technician had started with rule number one of troubleshooting, which is to check the obvious, we would have saved weeks of back-and-forth.

They did not ask me if the reporting function was switched on. They did not suggest looking in that settings corner. Instead, we burned cycles swapping emails, reviewing logs, and speculating about deeper issues.

And here is the kicker: I, the customer, was frustrated. I guarantee the support tech was frustrated too. Nobody likes to feel stuck in an endless loop without progress.

All of it could have been avoided by asking one simple question:
“Have you checked if the reporting function is turned on?”

Why the Fundamentals Matter So Much

It is tempting to dismiss this as obvious. Of course you check the basics. Everyone knows that. But here is the problem: knowing is not the same as doing.

In IT, we deal with complexity every day. Cloud architectures, virtualization stacks, security layers, and automation pipelines fill our work with nuance. Because of that, we sometimes assume that problems must be complex too. But often, they are not.

Think about it:

• The server will not boot. It turns out the power strip got bumped.
• The network is down. It turns out the cable is unplugged.
• The Wi-Fi is out. It turns out someone flipped the wrong switch in the wiring closet.

These are not advanced mysteries. They are simple, almost embarrassingly simple. But they are also common. And when we forget the basics, we risk turning small hiccups into long, painful sagas.

What This Means for IT Professionals

So how do we keep ourselves honest? How do we make sure we do not skip the fundamentals when we are knee-deep in a troubleshooting session? Here are a few practical ideas.

1. Build a Troubleshooting Checklist

Pilots use checklists before every flight, no matter how many hours they have logged. Why? Because memory is fallible. IT pros can benefit from the same discipline.

Your checklist might start with:

• Is it plugged in?
• Is it powered on?
• Are the cables secure?
• Are the switches in the correct position?
• Has anything obvious changed?

This is not about doubting your competence. It is about protecting yourself from oversight.

2. Teach the Basics to Your Team

If you manage IT staff, bake this into your culture. Make it normal to ask so-called “dumb” questions such as “Is it turned on?” or “Can you confirm the cable is connected?” Make it clear that it is not a sign of weakness. It is a sign of professionalism.

When junior staff see senior engineers model this behavior, they learn that real expertise means covering all bases, not just flexing technical chops.

3. Communicate Clearly with Customers

When you are troubleshooting with an end-user, do not assume they have checked the basics. Ask politely:

• “Can you confirm the device is powered on?”
• “Would you mind double-checking that the cable is secure?”

The key is to ask without sounding condescending. Frame it as teamwork, not interrogation.

4. Embrace the Five Principles

In my book The Compassionate Geek: How Engineers, IT Pros, and Other Tech Specialists Can Master Human Relations Skills to Deliver Outstanding Customer Service, I outline five principles of IT customer service:

• Technical competence
• Compassion
• Empathy
• Good listening skills
• Treating others with dignity and respect

Troubleshooting is not just about solving technical problems. It is about how you engage with the people affected. When you ask a customer if their device is plugged in, do it with empathy. When you remind your team to check the basics, do it with respect. Competence and compassion work best when paired together.

The Payoff: Saved Time and Less Frustration

Here is the bottom line: starting with the basics saves everyone time, energy, and frustration. It builds trust with your customers. It reduces stress on your team. And it reinforces your reputation as someone who gets things done efficiently.

Think back to my LearnDash example. Weeks of unnecessary back-and-forth could have been avoided by one simple question. Imagine how many similar situations play out every day in IT departments around the world. That is a lot of wasted time and goodwill.

By contrast, when you start with the fundamentals, you not only fix problems faster, you also make life easier for yourself and your customers.

A Quick Challenge for You

Here is a challenge: the next time you are troubleshooting, force yourself to ask the most basic questions first. Even if you are sure the answer is obvious. Even if it feels beneath your skill level.

Ask:

• Is it turned on?
• Is it plugged in?
• Is the breaker thrown?
• Is the switch in the right position?

You might be surprised at how often that is all it takes. And when it is not, you will have the confidence of knowing you covered the fundamentals before moving deeper.

Final Thoughts

In IT, it is easy to get caught up in the complexity of our work. But complexity should not distract us from simplicity. The basics matter. They always have, and they always will.

So the next time you are knee-deep in logs, configurations, and packet captures, take a step back. Ask the obvious questions. Check the basics.

Because sometimes, the smartest thing you can do is the simplest.

And never forget troubleshooting rule number one: Always start with the physical layer.

Next Level IT Customer Service Training

Enroll your team now in Compassionate Geek IT online customer service training so they can work together, get things done, and take care of customers.