Ready for Linux

Switch with confidence

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 01 · Beginner

Terminal Navigation

Learn how to navigate the Linux file system, move using relative and absolute paths, and learn the shortcuts that make terminal navigation faster.

Read the filesystem map, inspect files, and navigate without getting lost.

Read the Terminal Navigation course guide →

8 lessons — view syllabus
  1. Root, home, and you

    Understand the filesystem tree and locate your home directory.

  2. See what is around you

    List directory contents, including hidden entries and details.

  3. Follow a relative path

    Navigate through directories using a path relative to your current location.

  4. Go up and go home

    Use parent and home shortcuts instead of typing full paths.

  5. Navigate from root

    Recognize and use paths that begin at the filesystem root.

  6. Important directories

    Learn what common top-level directories are for and safely inspect a file.

  7. Let Tab finish the path

    Use Tab completion to navigate quickly and avoid typing mistakes.

  8. Navigation mission

    Combine your map, paths, shortcuts, completion, and read-only inspection.

Supporting videos

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
  1. Make the shell do something

    Meet Bash and create your first empty file with touch.

  2. Recover and try again

    Read an error, correct a command and leave unfinished input without losing your files.

  3. Build a useful workspace

    Prepare directories for a small project using mkdir.

  4. Put text into a file

    Use printf to write a line, then save its output with >.

  5. Write a note you can read back

    Write a short project note and inspect its contents.

  6. Keep a filename together

    Use quotes or an escaped space to pass a filename as one argument.

  7. Keep an original and make a copy

    Copy a project brief without changing its original.

  8. Put files where they belong

    Move a file out of an inbox and give it a useful name.

  9. Remove only what you mean to remove

    Inspect a scratch file, delete that exact file, and preserve the useful note.

  10. 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
  1. Read a short file with cat

    Display a text file and find the information you need.

  2. Inspect the beginning with head

    Read just the beginning of a file and choose how many lines to show.

  3. Inspect the ending with tail

    Find the latest message at the end of a prepared log.

  4. Edit, save, and exit nano

    Add a line in a text editor, save it, and return to the shell.

  5. Edit, save, and exit vi

    Switch modes deliberately, save a small edit, and leave vi confidently.

  6. Back up a note before editing

    Keep a backup, update a project note, and check both versions.

  7. 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
  1. Find a file by its name

    Search a directory tree when you know a filename but not its location.

  2. Narrow a search by type and pattern

    Find regular files with a filename pattern, excluding directories with similar names.

  3. Let Bash match filenames

    Distinguish Bash filename expansion from find patterns and grep text searches.

  4. Find matching lines with grep

    Search inside a file for literal text and read the matching lines.

  5. Search across letter case and show line numbers

    Find mixed-case text and report where it occurs in a file.

  6. Find which files contain a message

    Search a whole project and list the files containing a marker.

  7. Match a status at the start

    Use a start anchor and field delimiter to distinguish SENT from lookalike statuses.

  8. Save the lines that matter

    Collect matching log lines into a separate evidence file.

  9. 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
  1. Count lines with wc

    Count the lines in a prepared file and interpret the result.

  2. Send output to another command

    Connect a familiar file reader to a line counter before building larger pipelines.

  3. Select a field with cut

    Extract a column from simple delimiter-separated records.

  4. Sort text and numbers

    Recognize when numeric sorting differs from ordinary text ordering.

  5. Understand what uniq removes

    Collapse adjacent repeated lines and distinguish groups from global uniqueness.

  6. Connect commands with a pipe

    Pass output between commands and save an alphabetized unique list.

  7. Translate character case with tr

    Feed text to tr and turn lowercase letters into uppercase output.

  8. Replace text with sed

    Learn a small substitution program and save its output separately.

  9. Choose output fields with awk

    Read whitespace-separated records and print selected fields.

  10. 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
  1. Look inside an archive with tar

    List the paths stored in a prepared archive without extracting it.

  2. Create a tar backup

    Create a real archive that preserves a project's paths and contents.

  3. Restore into a separate directory

    Restore a prepared archive into a chosen destination without overwriting a working project.

  4. Compress and restore one file with gzip

    Compress a file while keeping it, then decompress a prepared copy.

  5. Combine tar and gzip

    Create a compressed project archive and prove it restores correctly.

  6. Create a ZIP archive

    Package a directory using recursive ZIP creation and inspect its contents.

  7. Restore a ZIP into a chosen directory

    Inspect a prepared ZIP, choose an extraction directory, and check the restored files.

  8. Compare file contents with sha256sum

    Compare checksums when filenames or a visual inspection are not enough.

  9. 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
  1. Save commands as a Bash script

    Save familiar commands and run them together with Bash.

  2. Store and quote a value

    Name a value once and expand it without splitting spaces.

  3. Understand the command environment

    Locate commands and pass a named value to a child Bash process.

  4. Pass information into a script

    Reuse the same saved commands with different input values.

  5. Signal success or failure

    Distinguish printed output from the status a script returns.

  6. Test whether a regular file exists

    Use test to turn a file question into an exit status.

  7. Choose an action with if and else

    Run one set of commands when a condition is true and another when it is false.

  8. Check inputs and report errors

    Reject incorrect argument counts without mixing error messages into useful output.

  9. Repeat work with a for loop

    Apply the same command to each supplied value without losing spaces.

  10. Capture an answer from a command

    Store a command's output in a variable and use it in a report.

  11. Name a reusable group of commands

    Define a function once and call it with different values.

  12. Diagnose a broken script

    Use syntax checks and execution tracing to repair a script, then verify varied inputs.

  13. 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
  1. Prepare the release workspace

    Read a project brief and prepare a working handoff without changing the originals.

  2. Find the current rollout evidence

    Find the current log and the recovery guide among plausible distractors.

  3. Repair the working release note

    Make one requested change while preserving unrelated text and the source copy.

  4. Turn shipment records into a report

    Build a distinct destination list from sent shipments rather than counting raw rows.

  5. Make the destination report reusable

    Turn the text workflow into a script with a clear input and error interface.

  6. Verify a prepared release backup

    Inspect and restore an independent reference archive into a separate destination.

  7. 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
  1. Meet the users sharing this workspace

    Use whoami, id and groups to inspect fictional Linux identities.

  2. Read permissions and try opening a file

    Inspect ls -l output, then compare a teammate's read with an outsider's denied read.

  3. See which permission class Linux selects

    Test an owner denied by owner bits while a teammate can read through group bits.

  4. Explore directory read, write and search

    List names without opening files, and open a known path without listing its directory.

  5. Separate editing contents from removing a name

    Try writes and removals in two directories with different access rules.

  6. Set numeric modes and verify sharing

    Use chmod 600, 640 and 750, then test what Bob and Cara can access.

  7. Change selected permissions with symbolic chmod

    Add one group right, clear others' rights and verify the resulting behavior.

  8. Repair a file's owner and owning group

    Use a scoped simulated ownership change and change the group of a file you own.

  9. Make a readable script directly executable

    Compare bash review.sh with ./review.sh, then grant the exact execution rights needed.

  10. 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
  1. Match the distribution to its package family

    Use a prepared distribution record to choose a relevant package-manager family.

  2. Separate refreshing metadata from upgrading software

    Distinguish installed versions from repository candidates after an APT metadata refresh.

  3. Review the whole package transaction

    Inspect more than the requested package name before approving a proposed transaction.

  4. Distinguish a program from its running processes

    Read a prepared process list and identify two instances of the same program.

  5. Read process states and resource columns

    Separate CPU, memory and process state in a prepared ps-style snapshot.

  6. Plan an intentional process stop

    Distinguish a graceful termination request from an uncatchable termination signal.

  7. Separate shell job numbers from process IDs

    Interpret a prepared job table without confusing its local job number with a PID.

  8. 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
  1. Identify services and unit types

    Distinguish a supervised service from its process and from other unit types.

  2. Separate active state from startup settings

    Read current service state independently of its enablement setting.

  3. Choose the action that matches the goal

    Distinguish immediate service actions, startup settings and configuration reloads.

  4. Read a unit definition and its dependencies

    Separate startup ordering from dependency activation in a prepared unit file.

  5. Scope a log investigation

    Identify the host, boot, time zone and service before interpreting a log.

  6. Filter prepared service logs

    Use familiar grep filters to collect only the requested boot and service.

  7. Trace a failure before proposing a fix

    Separate an application error, a manager summary and an unverified recovery.

  8. 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
  1. Separate disks, partitions and filesystems

    Distinguish a device, a partition, a filesystem and its mount point.

  2. Map a path to its mounted filesystem

    Choose the most specific mount point containing a requested path.

  3. Read capacity on the correct filesystem

    Use available-space columns and explicit units on the filesystem serving the target path.

  4. Compare directory usage without mixing measurements

    Rank prepared directory allocation totals with the existing numeric sort tool.

  5. Distinguish inode exhaustion from data-space exhaustion

    Compare inode availability separately from free data space.

  6. Read filesystem types and mount configuration

    Distinguish a configured filesystem entry from the currently mounted state.

  7. Distinguish read-only mounts from file permissions

    Use the actual mount options before proposing a permission change.

  8. 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
  1. Meet your network and its interfaces

    Explore a fictional network and inspect addresses on two computers.

  2. Find the route a packet will take

    Use ip route and route lookups to distinguish local, default and specific routes.

  3. Test reachability with ping

    Send bounded ICMP probes, compare replies and stop a running command.

  4. Follow a path with traceroute

    Compare hop limits with missing probe replies along a working path.

  5. Ask DNS with dig

    Distinguish an address answer, a missing name and an unresponsive resolver.

  6. Test a TCP port with telnet

    Experience connected, refused and timed-out TCP attempts.

  7. Check HTTP and TLS with curl

    Read HTTP status, inspect curl exit codes and verify a simulated app repair.

  8. Find a listener that only accepts local clients

    Use ss on the server to explain why a healthy app refuses remote connections.

  9. Verify a host and open a simulated SSH session

    Check a trusted fingerprint, connect on port 2222 and recognize the remote prompt.

  10. Recover from a resolver failure

    Prove that an IP works while name resolution fails, then verify a staged repair.

  11. Restore a missing default route

    Find a local network that works and a missing route to remote destinations.

  12. 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
  1. Review least privilege across security layers

    Choose the smallest authorized change without confusing independent access checks.

  2. Plan an update with verification and rollback

    Separate a package change proposal from an applied and verified maintenance result.

  3. Preserve access while reviewing SSH hardening

    Require a tested replacement access path before restricting an existing login method.

  4. Review a scoped firewall rule

    Match protocol, port, source and rule order in a simplified incoming-traffic policy.

  5. Investigate mandatory access-control evidence

    Collect the relevant denial without bypassing the policy or assuming mode bits are the only layer.

  6. Read a cron schedule before installing it

    Interpret a five-field user crontab with an explicit time zone.

  7. Review a scheduled job environment

    Make the job identity, interpreter, paths and output expectations explicit.

  8. Distinguish a systemd timer from its service

    Separate a timer’s activation schedule from the result of the service it triggers.

  9. Prove a local maintenance restore

    Restore prepared text and binary files into a separate destination before claiming local recovery evidence.

  10. Review a security maintenance window independently

    Combine change scope, access preservation, schedule interpretation and honest recovery evidence.

Supporting videos