Welcome to the Course

What this course covers

This is a complete, beginner-to-intermediate journey through Linux (the operating system that runs most of the internet) and Bash (the shell language you use to command it and to automate work). We don't assume you've ever opened a terminal. We start from "what even is Linux?" and finish with you writing admin-grade scripts that back up data, monitor system health, and run automatically on a schedule.

The course is organised so each skill builds on the last. Rather than a pile of disconnected commands, you're climbing a ladder — and every rung is something you'll genuinely use:

Concretely, the course spans 18 sections and 76 lessons, plus four capstone projects that mirror real DevOps and sysadmin work. Along the way you'll touch every part of operating a Linux machine: navigating the filesystem, managing files and permissions, taming text and logs with tools like grep and awk, watching and controlling processes, and then turning all of it into reusable, well-tested Bash scripts. You don't need to memorise that list now — just know there's a clear arc, and we never skip a rung.

What you'll be able to do

Goals matter more than topics. Here's the honest, practical version of what you'll walk away able to do — the kind of thing you can put on a résumé and actually back up in an interview or on the job:

• Operate any Linux box from the keyboard alone. Drop into an unfamiliar server over SSH and find your way around without a graphical desktop.
• Manage the system with confidence. Files, directories, permissions, users, processes, and services — create, inspect, and fix them safely.
• Slice and transform text and logs. Answer questions like "which 5 IP addresses hit us most today?" using pipelines of grep, sort, uniq, awk, and sed.
• Write robust Bash scripts. With variables, conditionals, loops, functions, and real error handling — not fragile one-liners that break on the first surprise.
• Automate the boring stuff. Schedule jobs with cron, build backup and monitoring tools, and ship scripts a team could rely on.

To make that tangible, here's a tiny taste of the destination. This is the kind of script you'll write effortlessly by Section 14 — don't worry about understanding every line yet, just notice that it reads almost like plain English:

#!/usr/bin/env bash
# backup.sh — archive a folder with today's date in the name
src="$HOME/project"
dest="$HOME/backups/backup-$(date +%Y%m%d).tar.gz"

tar -czf "$dest" "$src"
echo "Backed up $src to $dest"

And running it looks like this:

you@linux:~$ ./backup.sh
Backed up /home/you/project to /home/you/backups/backup-20260614.tar.gz

That's the whole point of the command line and scripting: a few precise lines do work that would take dozens of mouse clicks — and they do it the same way every single time.

Prerequisites and your environment

The prerequisites are refreshingly small: basic computer literacy. If you can install software, find a downloaded file, and aren't afraid to try things, you're ready. No prior Linux experience and no programming background are required. If you've never written a line of code, that's completely fine — we'll teach the programming concepts (variables, conditions, loops) as we reach them in the scripting sections.

The one thing you do need is a place to practise. You can't learn to swim from the side of the pool, and you can't learn Linux by only reading. You need a real terminal to type into. You have three good options, and all of them land you at the exact same Bash prompt:

• WSL (Windows Subsystem for Linux) — if you're on Windows, this is the quickest start. It runs a real Ubuntu inside Windows with no separate machine to manage. You can have a terminal open in minutes.
• A virtual machine — tools like VirtualBox (free) or VMware run a complete, isolated Ubuntu inside a window on Windows, macOS, or Linux. Great for experimenting freely: if you break it, you delete it and start over.
• A cloud server — a small Linux instance on AWS, DigitalOcean, or similar, that you reach over SSH. This is closest to how you'll use Linux at work, and many providers offer a free tier or a few dollars a month.

We'll walk through setting one of these up step by step in Lesson 1.3. For this lesson, you just need to decide which one you'll use. If you're on Windows and unsure, pick WSL. If you want a self-contained sandbox, pick a VM. Either is a great choice for the whole course.

How to get the most from this course

Here's an uncomfortable truth about online courses: most people start them and never finish. The difference between starting and finishing is rarely talent — it's method. A few simple habits will carry you all the way to the capstones.

Type every command yourself. Reading ls -lah and running ls -lah are completely different experiences. Your fingers learn the rhythm, you see the real output, and — crucially — you make mistakes and recover from them. That recovery is the skill. Keep a terminal open beside this page and run along with each example.

Go in order, at least the first time. Later sections lean on earlier ones. The scripting in Section 9 assumes you can already move around the filesystem from Section 2 and redirect output from Section 7. Following the sidebar in order means nothing ever feels like it came out of nowhere.

Do the labs and quizzes. Each lesson ends with a hands-on exercise and a short quiz. They're not busywork — they're where the knowledge moves from "I read it" to "I can do it." Mark each lesson complete when you finish so the sidebar tracks your progress and you can always see how far you've come.

Build a tiny daily habit. Thirty focused minutes a day beats a five-hour marathon once a fortnight, because command-line fluency — like a language — comes from repetition. Consistency is the real secret.

rm -rf /            # ☠️ NEVER run this — it tries to delete everything

Further reading

• The GNU Bash Reference Manual — the official, authoritative Bash documentation (bookmark it now).
• Ubuntu on WSL — the quickest way to get a real Linux terminal on Windows.
• Linux Journey — a friendly companion reference for the fundamentals we'll cover.