Linux Roadmap: 6-Month Plan by Role and Certification
13 min read ยท 2026-11-04
A good linux roadmap follows this order: set up a lab you can break, learn the terminal and the filesystem, then add permissions, packages, processes, Bash scripting, systemd, storage, networking, SSH, security and troubleshooting. Each layer depends on the one before it. At about 8 to 10 hours a week, this plan runs for six months, and by the end you can run a real server on your own.
Most Linux roadmaps online are just lists of topics. This one gives each phase a duration, a mini project and a pass or fail test, so you always know when you are ready to move on. It also shows what to add for sysadmin, DevOps, cloud or security work, where certifications like LPIC-1, RHCSA, LFCS and Linux+ fit, and how to turn the plan into something a manager can approve and follow.
The roadmap at a glance
Goal: Set up, script, secure and troubleshoot Linux systems, from a local virtual machine to a server on the internet, with proof of each skill. Duration: 26 weeks (about 6 months) at 8 to 10 hours per week
Lab Setup and Terminal Basics (Weeks 1 to 3)
Move around the filesystem and work with files from the command line, without the desktop.
- Install Ubuntu in a virtual machine with VirtualBox, UTM or Hyper-V, and take a snapshot before every experiment.
- Move around with cd, ls and pwd, and learn the difference between absolute and relative paths.
- Create, copy, move, find and delete files with touch, cp, mv, find and rm. Read file contents with cat, less, head and tail.
- Read man pages and the --help output before you search the web.
- Edit files in nano, then learn the basic Vim moves: insert mode, save, quit and search.
Milestone: You spend a full working session on file tasks using only the terminal, and you can explain what /etc, /var, /home, /usr and /tmp hold.
Users, Permissions and Packages (Weeks 4 to 7)
Control who can do what on the system, and install software the clean way.
- Manage users and groups with useradd, usermod, passwd and groups.
- Read and change permissions with chmod and chown, in both symbolic and octal form.
- Give sudo rights safely through visudo and the sudoers.d directory.
- Install, update and remove software with apt, then add a second VM running Rocky Linux to learn dnf.
- Look at processes with ps, top and htop, and send signals with kill.
Milestone: You set up a shared project folder where two users can both write and nobody else can read, on both Ubuntu and Rocky Linux.
Text Processing and Bash Scripting (Weeks 8 to 11)
Chain small tools together and write scripts that handle repetitive work for you.
- Chain commands with pipes and redirection, and check exit codes.
- Search and reshape text with grep, sed, awk, cut, sort and uniq.
- Write Bash scripts with variables, conditions, loops and functions.
- Add set -euo pipefail, quoting and argument checks so scripts stop cleanly when something fails.
- Schedule jobs with cron and with systemd timers.
Milestone: A scheduled backup script runs every night, keeps the last seven archives and logs success or failure to a file you can read.
Services, Boot and Storage (Weeks 12 to 16)
Run long-lived services and manage disks, filesystems and logs.
- Start, stop, enable and inspect services with systemctl, and read their logs with journalctl.
- Write your own systemd unit file for a small app or script.
- Learn the boot sequence: firmware, bootloader, kernel, systemd targets.
- Partition a virtual disk, create ext4 and XFS filesystems, and mount them at boot through fstab.
- Create, extend and snapshot logical volumes with LVM, and track space with df and du.
Milestone: Your own app runs as a systemd service. It starts after a reboot, logs to the journal and keeps its data on a separate LVM volume.
Networking, SSH and Security (Weeks 17 to 21)
Connect systems safely and find network problems on your own.
- Check interfaces, routes and open ports with ip addr, ip route and ss.
- Debug connections with ping, dig, curl, traceroute and tcpdump.
- Set up SSH keys, then turn off password and root logins.
- Set up a firewall with ufw on Ubuntu or firewalld on Rocky Linux, and open only the ports you need.
- Serve a website through Nginx with a Let's Encrypt TLS certificate, then add fail2ban and automatic security updates.
Milestone: A public VPS serves your site over HTTPS and accepts SSH logins by key only. Its firewall rules list only the ports you meant to open.
Troubleshooting, Role Track and Certification (Weeks 22 to 26)
Fix failures in a set order, start the extra skills for your target role, and check your level against a real exam.
- Break your VMs on purpose and fix them: a bad fstab entry, a full disk, a service that will not start, a wrong permission.
- Investigate high load with top, vmstat, iostat and the journal.
- Learn the basics of SELinux on Rocky Linux or AppArmor on Ubuntu, and read denial messages.
- Start the first item of your role track (see the section below).
- Take timed practice labs that follow the objectives of your chosen certification.
Milestone: You fix five broken VMs within a set time limit without looking up the answers, and you write a short note on each fix.
Pick Your Target Role Before Week One
Linux is a base skill, not a job title. A system administrator, a DevOps engineer and a security analyst all need phases 1 to 5 of this plan. What changes is how they spend the last month and the months after it. If you pick your role first, you know which distribution to practice on, which certification to aim for and which projects to build.
The core plan is the same for everyone. The role track is what you add in week 22 and keep working on after week 26. If you are not sure yet, follow the system administrator track. It covers the most ground, and every other role builds on it.
- System administrator: go deeper on storage, LVM and RAID, user management at scale, backups and restore tests, SELinux and patching. Practice on Rocky Linux, since many company servers run on the Red Hat family.
- DevOps or SRE: Git, Ansible to rebuild servers from code, Docker and then Kubernetes basics, CI pipelines, and monitoring with metrics and alerts. Bash and Python both matter here.
- Cloud engineer: run Linux instances in a public cloud. Learn cloud images, startup scripts, storage volumes and security groups, and automate their setup. Networking from phase 5 becomes your main skill.
- Security: log analysis, hardening checklists, file integrity, firewalls, SSH auditing and reading auth logs. Your scripts from phase 3 become small detection tools.
- Developer: the shell, Git, processes, environment variables, permissions, containers and reading logs. You can spend less time on storage and boot, but do not skip them completely.
Choosing a Distribution and a Lab Setup
The distribution matters less than online arguments suggest. Start on Ubuntu or Debian, because they have plenty of tutorials and use the apt package manager. From phase 2, add Rocky Linux or AlmaLinux. Both follow Red Hat Enterprise Linux and use dnf. The shell, systemd, networking and permissions work almost the same way on both families, so a second VM costs you little and gets you comfortable on both.
Your lab matters more than your distribution. Rebuild it from scratch every few weeks. If you cannot rebuild it quickly, your notes or scripts are missing steps.
- Local virtual machines: your main lab. With snapshots, you can break something and go back in seconds. That is how you learn boot, disks and recovery without risk.
- WSL2 on Windows: handy for daily terminal work and scripting, but it hides the boot process, real disks and part of systemd. Use it next to a VM, never as your only lab.
- A small cloud VPS: for phase 5. A machine open to the internet shows real login attempts in your logs, and that teaches security faster than any course.
- An old laptop or a Raspberry Pi: optional. Real hardware gives you real problems with drivers, power and networks.
Concepts That Make Everything Click
Linux gets much easier once a few ideas sink in. Everything is a file, including devices and the process information under /proc. Programs are small and work together: they read standard input and write standard output, so you can pipe one into the next. Permissions are three sets of read, write and execute bits (owner, group, everyone else), plus a few special bits.
The other big idea is that most of the system is plain text. Services read their settings from files in /etc, logs go to the journal or to /var/log, and you can investigate almost any problem by reading something. When you are stuck, ask three questions in this order: which process is involved, which config file does it read, and what do its logs say?
- Standard input, standard output, standard error and exit codes.
- Users, groups, permission bits, setuid, setgid and the sticky bit.
- Processes, PIDs, signals, and parent and child processes.
- systemd units, targets and dependencies.
- Mount points, inodes, and how one directory tree can span several disks.
A Weekly Routine That Keeps the Plan on Track
Over six months, motivation tends to drop around week eight. A fixed weekly routine protects you better than willpower does. At 8 to 10 hours a week, split the time into short weekday sessions and one longer lab session at the weekend.
If you have less time, keep the order and stretch the phases instead of skipping any. A phase you skip now comes back as a gap later, usually during troubleshooting.
- Three weekday sessions of about one hour: new commands and concepts, each one tested right away in the VM.
- One long session of three to four hours: the phase project, with a snapshot before you start and a written note at the end.
- Fifteen minutes at the end of the week: update your cheat sheet, check your progress against the milestone and plan next week.
- Daily habit: do one ordinary task in the terminal that you would usually do with a mouse.
Projects That Prove Linux Skills
Reading about commands will not make you fluent. Running something you care about will. Every phase above ends with a project, and together they make a portfolio. Put the scripts, unit files and config files in a Git repository, with a short write-up of what broke and how you fixed it. Those troubleshooting notes often impress more than the project itself, because they show how you think.
Once phase 5 works, rebuild your public server with an Ansible playbook so the setup can be repeated. That single project connects Linux administration to DevOps and cloud work.
- Phases 1 and 2: a shared folder setup with documented users, groups and permissions on two distributions.
- Phase 3: a backup script with rotation and logging, plus a script that counts failed SSH logins by IP address.
- Phase 4: a custom systemd service with its data on its own LVM volume.
- Phase 5: a hardened VPS serving your site over HTTPS.
- Phase 6: a notebook of five broken systems you fixed, with the cause and the fix for each.
Linux Certifications: Which One and When
You do not need a certification to work with Linux, but one gives your plan a fixed date and an outside check. Put the exam in the final phase, once your practice labs pass without help.
A useful order: sysadmins in Red Hat shops take RHCSA, then RHCE. DevOps and cloud profiles take LFCS, then a container or cloud certification. If you want a broad, vendor-neutral credential first, start with LPIC-1 or Linux+. Codes, formats and prices change, so check the current objectives on the official page before you book.
- CompTIA Linux+: vendor-neutral. A good fit for support and junior admin roles, and for teams that already follow CompTIA certifications.
- LPIC-1: vendor-neutral. According to LPI's official LPIC-1 page, it takes two exams, 101-500 and 102-500. Each has 60 multiple-choice and fill-in-the-blank questions in 90 minutes. There are no prerequisites, and the certification stays valid for 5 years.
- LFCS: from the Linux Foundation, distribution-neutral and performance-based. A strong choice for DevOps and cloud roles.
- RHCSA: Red Hat's official RHCSA page says you earn it by passing EX200, a performance-based exam. For people new to Red Hat Enterprise Linux, Red Hat recommends the RH124 and RH134 courses. For experienced Linux or UNIX admins, it recommends the RH200 Rapid Track course with exam. It fits companies that run the Red Hat family.
- RHCE: the next step after RHCSA, focused on automation.
Turning This Linux Roadmap Into a Plan Your Manager Will Approve
If you are learning Linux for your job, for example for a migration, a move into DevOps or a new role, your manager will want a plan, not a course list. The phases above already include what a manager looks for: a duration, a deliverable and a test for each phase. You just need to fit them on one page, short and easy to check.
Plan a two-week buffer before the exam and say so up front. Managers trust a plan with a buffer more than one that promises everything on time.
- Goal and reason: one sentence that ties the skill to a team need, such as taking over server patching or supporting a move to Linux servers.
- Time requested: the weekly hours, when they happen, and whether some come out of work time.
- Six milestones with dates: one per phase, each with a deliverable your manager can see, like a working service, a script in the team repository or a fixed test system.
- Support needed: a lab environment, course access or exam fees, listed clearly.
- Check-ins: a short demo at the end of each phase instead of a status update.
How to Know You Are Ready
You are ready for junior sysadmin, support or DevOps work when you can take a fresh server, secure it, deploy a service on it and track down problems from its logs without panicking. The number of commands you know matters less than whether you follow a reliable process: check the service status, read the logs, check the network, confirm permissions, and change one thing at a time.
Use this checklist as your final test.
- You can rebuild your public server from your notes or playbook alone.
- You can explain every line of your backup script and every firewall rule.
- You can recover a VM that will not boot because of a bad fstab entry.
- You can find out which process is using a port, a disk or the CPU.
- Your practice labs for your chosen certification pass within the time limit.
Common mistakes to avoid
- Running everything as root or with sudo out of habit hides permission problems. Work as a normal user and use sudo only when you need it.
- Copying commands from the internet without understanding them can break a system. Read the man page and test in a snapshot VM first.
- Using chmod 777 to fix access errors opens security holes. Find the right owner and group, and grant only the bits you need.
- Learning on WSL alone leaves gaps in boot, disks and services. Keep a full virtual machine for phases 4 to 6.
- Collecting topics without building anything means little sticks. Finish the milestone project before you start the next phase.
- Putting a server online with password SSH and no firewall invites brute-force attacks. Set up keys, a firewall and updates before anything else.
Frequently asked questions
How long does it take to learn Linux?
Getting comfortable in the terminal takes a few weeks of daily use. This plan builds solid admin skills (scripting, services, storage, networking and troubleshooting) in about six months at 8 to 10 hours a week. After that you keep improving for years, mostly by running real systems and fixing what breaks.
Which Linux distro should a beginner start with?
Ubuntu is the easiest start, because it has a lot of documentation and a large community. If you are aiming for company servers or the RHCSA, add Rocky Linux or AlmaLinux from the second phase. The skills overlap a lot, so do not spend more than an afternoon deciding.
Which Linux certification should I take first?
Base it on your target role. RHCSA fits teams that run Red Hat Enterprise Linux, LFCS fits DevOps and cloud work, and LPIC-1 or CompTIA Linux+ give you a broad, vendor-neutral start. Book the exam only once your timed practice labs pass without help.
What should I learn after the core Linux phases?
That depends on your role track. Sysadmins go deeper into storage, SELinux, backups and patching. DevOps and cloud profiles add Git, Ansible, Docker, Kubernetes basics and monitoring. Security profiles focus on log analysis and hardening. Keep running your public server while you learn, so your Linux skills stay sharp.
How much Linux do I need for DevOps?
You need everything in phases 1 to 5, plus strong troubleshooting from phase 6. On top of that, DevOps work expects Git, Ansible, Docker, Kubernetes basics and monitoring. Learn Bash first for glue scripts, then Python for automation that calls APIs or handles complex data.