Linux for IT Support: The Beginner Roadmap

If you work in IT support long enough, Linux eventually shows up like a weird little goblin in the corner of your ticket queue.

A vendor appliance runs Linux. A web server runs Linux. A security tool drops you into a shell. Someone says “just SSH into it and check the logs,” like that is a normal sentence and not a tiny career jump scare.

This guide is the beginner roadmap I’d give to a help desk tech, Windows admin, or early sysadmin who wants to stop feeling useless the second a terminal opens.

You do not need to become a kernel wizard. You do not need to daily-drive Arch. You do not need to memorize 400 commands while some bearded forum guy judges your sudo usage.

You need enough Linux to troubleshoot, navigate, read files, move stuff around, understand permissions, and avoid breaking the box in exciting new ways.

The goal: terminal confidence, not Linux cosplay

For IT support, Linux skill usually means five practical things:

1. You can get into a system with SSH.
2. You can move around the filesystem without getting lost.
3. You can inspect files, logs, users, services, and processes.
4. You can understand permissions well enough to fix access problems.
5. You can chain basic commands together to answer questions quickly.

That’s it. That is the first mountain.

The mistake beginners make is trying to learn Linux like it is an encyclopedia. They read command lists, bounce between YouTube videos, copy/paste random one-liners, and then forget everything because they never actually use it.

Linux sticks when you practice tiny real tasks.

Step 1: Learn how to move around

Start with navigation. Boring? Yes. Required? Also yes.

Learn these first:

pwd
ls
cd
clear

What they do:

• pwd shows where you are.
• ls lists files and folders.
• cd changes directories.
• clear cleans up the screen so your brain stops screaming.

Useful examples:

pwd
ls
ls -la
cd /var/log
cd ..
cd ~

The big beginner mistake: not knowing where you are before running commands. pwd is your “am I in the right room?” check.

If you only learn one habit this week, make it this:

pwd && ls -la

Run it when you feel lost. It tells you your location and what is around you.

Step 2: Understand the Linux filesystem

Windows has drive letters like C:\. Linux starts at /, called the root directory.

A few folders matter early:

Directory	What it usually means
/home	User files live here
/etc	System and app config files
/var/log	Logs, aka the first place you check when stuff is on fire
/tmp	Temporary files
/usr/bin	Many installed commands/programs
/opt	Optional/vendor-installed software

You do not need to memorize every folder. Just know enough to stop treating the system like a haunted house.

A very IT-support-ish first task:

cd /var/log
ls -la

That gets you into the neighborhood where many troubleshooting stories begin.

Step 3: Learn to read files without editing them

Before you edit anything, learn how to safely look.

Start with:

cat
less
head
tail

Examples:

cat config.txt
less /var/log/syslog
head -20 /var/log/syslog
tail -50 /var/log/syslog
tail -f /var/log/syslog

What matters at work:

• less lets you scroll through a file without changing it.
• tail -f watches a log live while you reproduce a problem.
• head and tail keep you from dumping a giant file into your terminal like a maniac.

Beginner mistake: using cat on huge logs. That is how you summon a wall of text and regret.

Use less for big files.

Step 4: Learn copy, move, rename, and delete carefully

These are the file handling basics:

cp
mv
rm
mkdir
rmdir

Examples:

mkdir notes
cp old.txt backup.txt
mv draft.txt final.txt
rm junk.txt
rmdir empty-folder

The command that deserves respect is rm.

Linux will often do exactly what you asked, even if what you asked was extremely dumb. There is no friendly Recycle Bin fairy waiting to save you.

Be careful with:

rm -rf

That command can delete a lot, very quickly. Learn it eventually, but do not make it your personality.

A better beginner habit:

ls target-file-or-folder

Then delete only after you confirm you are pointing at the right thing.

Step 5: Learn permissions before they ruin your afternoon

Linux permissions look like this:

-rw-r--r--
drwxr-xr-x

At first, that looks like a raccoon walked across the keyboard.

The short version:

• r means read.
• w means write.
• x means execute or enter, depending on file vs directory.
• Permissions apply to owner, group, and everyone else.

Commands to know:

chmod
chown
chgrp
ls -l

Example:

ls -l script.sh
chmod +x script.sh

That makes a script executable.

The beginner mistake is running this because Stack Overflow said so:

chmod 777 some-folder

777 means everyone can read, write, and execute. Sometimes it “fixes” the immediate issue by creating a bigger security problem. Don’t use it as duct tape unless you understand the tradeoff.

Step 6: Learn users and privilege

In Linux, normal users should not be able to wreck the whole machine by accident. Admin-level actions usually require privilege.

Commands to know:

whoami
id
sudo
su
passwd

Examples:

whoami
id
sudo systemctl status ssh

sudo means “run this command with elevated privileges.”

The habit to build: try normal commands first, then use sudo only when the task genuinely needs admin access.

Beginner mistake: prefixing everything with sudo because one command failed once. That is like using a chainsaw to open Amazon boxes.

Step 7: Learn process troubleshooting

When someone says “the app is hung” or “the server is slow,” processes matter.

Commands to know:

ps
top
pgrep
kill
killall

Examples:

ps aux | grep nginx
top
pgrep ssh
kill 1234

The important concept: programs run as processes, and every process has an ID.

Beginner mistake: killing random processes without knowing what they do. In production, that is how your quiet Tuesday becomes a learning experience.

Step 8: Learn logs and services

A ton of Linux troubleshooting is just reading the thing that already told you what broke.

Commands to know:

journalctl
systemctl
tail
grep

Examples:

systemctl status ssh
journalctl -u ssh --since "1 hour ago"
tail -f /var/log/syslog
grep -i error /var/log/syslog

This is where Linux starts feeling useful. You are no longer guessing. You are asking the system what happened.

Beginner mistake: skipping logs and trying random fixes. Logs are not always beautiful, but they are usually less chaotic than guessing.

Step 9: Learn basic networking commands

If you work help desk or sysadmin, networking issues will find you.

Learn these:

ping
ip addr
ss
curl
dig
traceroute
ssh

Examples:

ping 8.8.8.8
ip addr
ss -tulpn
curl -I https://example.com
dig example.com
ssh user@server

What these answer:

• Can I reach the network?
• What IP address do I have?
• What ports are listening?
• Is a web service responding?
• Is DNS working?
• Can I remote into the box?

Beginner mistake: treating every network issue as “the internet is down.” DNS, firewall rules, local services, routing, and ports can all be the actual problem.

Step 10: Practice in tiny missions

Do not learn Linux by reading command lists forever. Learn it by doing small missions.

Try missions like:

• Find your current directory.
• Create a folder and three files.
• Rename one file.
• Copy a file into another folder.
• Read the last 20 lines of a log.
• Find every .txt file under a directory.
• Make a script executable.
• Check what process is using a port.
• SSH into a practice box.
• Use grep to find an error in a fake log.

This is exactly why I built Shell Samurai around practice instead of passive tutorial hoarding. You learn commands faster when your brain has a job to do.

If you want a safe place to build that muscle, try the interactive app here:

Start practicing Linux in Shell Samurai

The beginner roadmap, in order

Here is the no-drama order I’d follow:

1. Navigation: pwd, ls, cd
2. Files: cat, less, head, tail
3. File operations: cp, mv, rm, mkdir
4. Permissions: chmod, chown, ls -l
5. Users/admin: whoami, id, sudo
6. Processes: ps, top, kill
7. Logs/services: journalctl, systemctl, grep
8. Networking: ping, ip, ss, curl, dig, ssh
9. Shell basics: pipes, redirects, aliases
10. Tiny Bash scripts

That is enough to make Linux feel like a tool instead of a haunted basement.

Final thought

Linux beginners usually do not need more motivation. They need a map, a safe practice environment, and permission to be bad at it for a little while.

You are not dumb because chmod looks weird. It is weird.

Start with the basics, practice small tasks, and build confidence one command at a time.