Linux course syllabus
Explore what you will learn
14 courses and 129 lessons covering terminal navigation, files, Bash scripting, backups, and Linux system concepts.
The first two Terminal Navigation lessons are free, with no account needed. The remaining lessons require course access. Each course below lists its topics, lesson outline, and optional supporting resources.
Course 02 · Beginner
Shell Essentials
Build a workspace, write and organize files, then prepare a project handoff independently in real Bash.
Write, copy, move, and deliberately remove files; prepare a project handoff.
Read the Shell Essentials course guide →
10 lessons — view syllabus
- Make the shell do something
Meet Bash and create your first empty file with touch.
- Recover and try again
Read an error, correct a command and leave unfinished input without losing your files.
- Build a useful workspace
Prepare directories for a small project using mkdir.
- Put text into a file
Use printf to write a line, then save its output with >.
- Write a note you can read back
Write a short project note and inspect its contents.
- Keep a filename together
Use quotes or an escaped space to pass a filename as one argument.
- Keep an original and make a copy
Copy a project brief without changing its original.
- Put files where they belong
Move a file out of an inbox and give it a useful name.
- Remove only what you mean to remove
Inspect a scratch file, delete that exact file, and preserve the useful note.
- Prepare a project handoff
Combine your file skills in an independent project handoff.
Supporting videos
Course 03 · Beginner
Reading and Editing Files
Read short files, inspect long documents, edit with nano and vi, and prepare a checked project update.
Inspect files and log results, edit in nano or vi, and verify a project update.
7 lessons — view syllabus
- Read a short file with cat
Display a text file and find the information you need.
- Inspect the beginning with head
Read just the beginning of a file and choose how many lines to show.
- Inspect the ending with tail
Find the latest message at the end of a prepared log.
- Edit, save, and exit nano
Add a line in a text editor, save it, and return to the shell.
- Edit, save, and exit vi
Switch modes deliberately, save a small edit, and leave vi confidently.
- Back up a note before editing
Keep a backup, update a project note, and check both versions.
- Review and publish a project update
Find a review outcome and prepare a checked update while keeping your sources.
Supporting videos
Course 04 · Beginner
Finding Files and Information
Locate files, search their contents, and collect useful evidence without changing the sources.
Locate files, search their contents, and prepare an evidence handoff.
9 lessons — view syllabus
- Find a file by its name
Search a directory tree when you know a filename but not its location.
- Narrow a search by type and pattern
Find regular files with a filename pattern, excluding directories with similar names.
- Let Bash match filenames
Distinguish Bash filename expansion from find patterns and grep text searches.
- Find matching lines with grep
Search inside a file for literal text and read the matching lines.
- Search across letter case and show line numbers
Find mixed-case text and report where it occurs in a file.
- Find which files contain a message
Search a whole project and list the files containing a marker.
- Match a status at the start
Use a start anchor and field delimiter to distinguish SENT from lookalike statuses.
- Save the lines that matter
Collect matching log lines into a separate evidence file.
- Investigate and prepare an incident handoff
Locate a log, find recovery instructions, and prepare evidence for a teammate.
Course 05 · Beginner
Pipes and Text Processing
Count, select, order and transform text, then connect tools to build useful reports.
Count, select, order and transform text; combine tools into checked reports.
10 lessons — view syllabus
- Count lines with wc
Count the lines in a prepared file and interpret the result.
- Send output to another command
Connect a familiar file reader to a line counter before building larger pipelines.
- Select a field with cut
Extract a column from simple delimiter-separated records.
- Sort text and numbers
Recognize when numeric sorting differs from ordinary text ordering.
- Understand what uniq removes
Collapse adjacent repeated lines and distinguish groups from global uniqueness.
- Connect commands with a pipe
Pass output between commands and save an alphabetized unique list.
- Translate character case with tr
Feed text to tr and turn lowercase letters into uppercase output.
- Replace text with sed
Learn a small substitution program and save its output separately.
- Choose output fields with awk
Read whitespace-separated records and print selected fields.
- Build a shipment destination report
Turn prepared shipment records into a clean destination list and a distinct-city count.
Course 06 · Beginner
Archives and Backups
Create, inspect and restore tar, gzip and ZIP backups, then verify the restored file contents.
Create and inspect archives, restore into a separate directory, and verify the original bytes.
9 lessons — view syllabus
- Look inside an archive with tar
List the paths stored in a prepared archive without extracting it.
- Create a tar backup
Create a real archive that preserves a project's paths and contents.
- Restore into a separate directory
Restore a prepared archive into a chosen destination without overwriting a working project.
- Compress and restore one file with gzip
Compress a file while keeping it, then decompress a prepared copy.
- Combine tar and gzip
Create a compressed project archive and prove it restores correctly.
- Create a ZIP archive
Package a directory using recursive ZIP creation and inspect its contents.
- Restore a ZIP into a chosen directory
Inspect a prepared ZIP, choose an extraction directory, and check the restored files.
- Compare file contents with sha256sum
Compare checksums when filenames or a visual inspection are not enough.
- Prove that a project backup restores
Create a compressed backup and demonstrate that the full project can be restored.
Course 07 · Intermediate
Bash Scripting
Save repeatable commands, handle arguments and decisions, then build a reusable file-report script.
Write Bash scripts with arguments, conditions, loops, functions, and useful exit codes.
Read the Bash Scripting course guide →
13 lessons — view syllabus
- Save commands as a Bash script
Save familiar commands and run them together with Bash.
- Store and quote a value
Name a value once and expand it without splitting spaces.
- Understand the command environment
Locate commands and pass a named value to a child Bash process.
- Pass information into a script
Reuse the same saved commands with different input values.
- Signal success or failure
Distinguish printed output from the status a script returns.
- Test whether a regular file exists
Use test to turn a file question into an exit status.
- Choose an action with if and else
Run one set of commands when a condition is true and another when it is false.
- Check inputs and report errors
Reject incorrect argument counts without mixing error messages into useful output.
- Repeat work with a for loop
Apply the same command to each supplied value without losing spaces.
- Capture an answer from a command
Store a command's output in a variable and use it in a report.
- Name a reusable group of commands
Define a function once and call it with different values.
- Diagnose a broken script
Use syntax checks and execution tracing to repair a script, then verify varied inputs.
- Build a reusable file-report script
Combine safe inputs, file tests, captured output and useful failure behavior.
Supporting videos
Course 08 · Intermediate
Terminal Confidence Project
Prepare a release handoff through focused project stages, then complete and restore it independently.
Organize a workspace, investigate prepared logs, produce a report, and restore a backup independently.
7 lessons — view syllabus
- Prepare the release workspace
Read a project brief and prepare a working handoff without changing the originals.
- Find the current rollout evidence
Find the current log and the recovery guide among plausible distractors.
- Repair the working release note
Make one requested change while preserving unrelated text and the source copy.
- Turn shipment records into a report
Build a distinct destination list from sent shipments rather than counting raw rows.
- Make the destination report reusable
Turn the text workflow into a script with a clear input and error interface.
- Verify a prepared release backup
Inspect and restore an independent reference archive into a separate destination.
- Complete the release handoff independently
Complete the whole project from the untouched sources and prove the handoff restores.
Course 09 · Beginner permissions
Users and Permissions
Practice identities, permission checks, chmod, group ownership and a scoped ownership repair in a fictional shared workspace.
Practice identities, permission changes and access checks in a fictional shared workspace; repair and verify a least-privilege handoff.
10 lessons — view syllabus
- Meet the users sharing this workspace
Use whoami, id and groups to inspect fictional Linux identities.
- Read permissions and try opening a file
Inspect ls -l output, then compare a teammate's read with an outsider's denied read.
- See which permission class Linux selects
Test an owner denied by owner bits while a teammate can read through group bits.
- Explore directory read, write and search
List names without opening files, and open a known path without listing its directory.
- Separate editing contents from removing a name
Try writes and removals in two directories with different access rules.
- Set numeric modes and verify sharing
Use chmod 600, 640 and 750, then test what Bob and Cara can access.
- Change selected permissions with symbolic chmod
Add one group right, clear others' rights and verify the resulting behavior.
- Repair a file's owner and owning group
Use a scoped simulated ownership change and change the group of a file you own.
- Make a readable script directly executable
Compare bash review.sh with ./review.sh, then grant the exact execution rights needed.
- Repair a least-privilege team workspace
Diagnose failed access, repair modes and group ownership, and verify allowed and denied operations.
Supporting videos
Course 10 · Linux concepts
Software and Processes
Review prepared Linux package plans, process snapshots, signals and shell jobs without applying system changes.
Analyze prepared package transactions, process snapshots, signals and shell jobs; live system changes are outside this lab.
8 lessons — view syllabus
- Match the distribution to its package family
Use a prepared distribution record to choose a relevant package-manager family.
- Separate refreshing metadata from upgrading software
Distinguish installed versions from repository candidates after an APT metadata refresh.
- Review the whole package transaction
Inspect more than the requested package name before approving a proposed transaction.
- Distinguish a program from its running processes
Read a prepared process list and identify two instances of the same program.
- Read process states and resource columns
Separate CPU, memory and process state in a prepared ps-style snapshot.
- Plan an intentional process stop
Distinguish a graceful termination request from an uncatchable termination signal.
- Separate shell job numbers from process IDs
Interpret a prepared job table without confusing its local job number with a PID.
- Review a software and process change plan
Combine distribution, package-transaction, process-identity and job-control reasoning.
Course 11 · Linux concepts
Services and System Logs
Read service state and unit definitions, filter prepared logs, and review a failure with evidence.
Analyze prepared service states, unit definitions and log evidence; live systemd administration is outside this lab.
8 lessons — view syllabus
- Identify services and unit types
Distinguish a supervised service from its process and from other unit types.
- Separate active state from startup settings
Read current service state independently of its enablement setting.
- Choose the action that matches the goal
Distinguish immediate service actions, startup settings and configuration reloads.
- Read a unit definition and its dependencies
Separate startup ordering from dependency activation in a prepared unit file.
- Scope a log investigation
Identify the host, boot, time zone and service before interpreting a log.
- Filter prepared service logs
Use familiar grep filters to collect only the requested boot and service.
- Trace a failure before proposing a fix
Separate an application error, a manager summary and an unverified recovery.
- Review a service incident independently
Combine service state, scoped evidence and a justified next step.
Course 12 · Linux concepts
Storage and Filesystems
Map paths to prepared mounts, compare capacity and usage, and investigate a storage incident with evidence.
Analyze prepared mounts, capacity, directory usage and inode counters; live disk administration is outside this lab.
8 lessons — view syllabus
- Separate disks, partitions and filesystems
Distinguish a device, a partition, a filesystem and its mount point.
- Map a path to its mounted filesystem
Choose the most specific mount point containing a requested path.
- Read capacity on the correct filesystem
Use available-space columns and explicit units on the filesystem serving the target path.
- Compare directory usage without mixing measurements
Rank prepared directory allocation totals with the existing numeric sort tool.
- Distinguish inode exhaustion from data-space exhaustion
Compare inode availability separately from free data space.
- Read filesystem types and mount configuration
Distinguish a configured filesystem entry from the currently mounted state.
- Distinguish read-only mounts from file permissions
Use the actual mount options before proposing a permission change.
- Review a storage incident independently
Combine the correct mount, capacity, inode and directory-usage evidence.
Course 13 · Beginner networking
Networking and Remote Work
Practice ip, ping, traceroute, dig, telnet, ss, curl and SSH in a staged fictional network. Diagnose faults, apply simulated repairs and verify recovery.
Practice networking commands in a fictional network, diagnose DNS, routing and application faults, and verify simulated remote access.
12 lessons — view syllabus
- Meet your network and its interfaces
Explore a fictional network and inspect addresses on two computers.
- Find the route a packet will take
Use ip route and route lookups to distinguish local, default and specific routes.
- Test reachability with ping
Send bounded ICMP probes, compare replies and stop a running command.
- Follow a path with traceroute
Compare hop limits with missing probe replies along a working path.
- Ask DNS with dig
Distinguish an address answer, a missing name and an unresponsive resolver.
- Test a TCP port with telnet
Experience connected, refused and timed-out TCP attempts.
- Check HTTP and TLS with curl
Read HTTP status, inspect curl exit codes and verify a simulated app repair.
- Find a listener that only accepts local clients
Use ss on the server to explain why a healthy app refuses remote connections.
- Verify a host and open a simulated SSH session
Check a trusted fingerprint, connect on port 2222 and recognize the remote prompt.
- Recover from a resolver failure
Prove that an IP works while name resolution fails, then verify a staged repair.
- Restore a missing default route
Find a local network that works and a missing route to remote destinations.
- Investigate a layered network incident
Restore a portal by separating DNS, listener and application faults.
Supporting videos
Course 14 · Linux concepts
Security and Maintenance
Review scoped security changes and schedules, investigate audit evidence, and prove a local archive restore.
Analyze security, update and scheduling plans and prove a local restore; live Linux administration is outside this lab.
10 lessons — view syllabus
- Review least privilege across security layers
Choose the smallest authorized change without confusing independent access checks.
- Plan an update with verification and rollback
Separate a package change proposal from an applied and verified maintenance result.
- Preserve access while reviewing SSH hardening
Require a tested replacement access path before restricting an existing login method.
- Review a scoped firewall rule
Match protocol, port, source and rule order in a simplified incoming-traffic policy.
- Investigate mandatory access-control evidence
Collect the relevant denial without bypassing the policy or assuming mode bits are the only layer.
- Read a cron schedule before installing it
Interpret a five-field user crontab with an explicit time zone.
- Review a scheduled job environment
Make the job identity, interpreter, paths and output expectations explicit.
- Distinguish a systemd timer from its service
Separate a timer’s activation schedule from the result of the service it triggers.
- Prove a local maintenance restore
Restore prepared text and binary files into a separate destination before claiming local recovery evidence.
- Review a security maintenance window independently
Combine change scope, access preservation, schedule interpretation and honest recovery evidence.