Learn

Your Environment - The Workshop Before the Work

Set up one working Windows terminal and one working Linux terminal so every later module starts from a stable base.

Open Windows Terminal and Ubuntu, run the verification commands, and explain what each one proved.

What Is an Operating System?

Understand what the operating system does, where the shell fits, and how user requests become real actions on hardware.

Explain the difference between hardware, operating system, and user tools in your own words.

The 7 Mental Models That Separate Experts from Beginners

Learn seven mental models that help you reason about OS problems instead of memorizing isolated commands.

Use at least three of the seven models to explain a simple OS task or failure.

The Forgetting Curve & Your Study System

Understand why review matters and build a repeatable first-week study routine that keeps commands and concepts from fading immediately.

Describe a simple 3-day review plan for one OS lesson and one matching practice step.

File System Architecture: How Your OS Organises Data

Understand the map of the file system well enough to recognize Windows drive-letter paths, Linux root-tree paths, and the difference between a file name and the data behind it.

Explain the shape of paths on Windows and Linux and identify whether a sample path is absolute or not.

Navigation: GUI First

Use the graphical file manager to build a reliable spatial map of paths, hidden files, and frequent locations before translating those actions to the command line.

Open the file manager, jump to a known path, reveal hidden files, and bookmark one location you expect to revisit.

Navigation: CLI Translation

Translate basic GUI navigation into terminal navigation using the current directory, listing commands, absolute and relative paths, and a few high-value movement shortcuts.

Use `pwd` or `Get-Location`, list contents, move with `cd`, and explain why the path worked.

File Operations: View and Read

Read files safely from the terminal, inspect the beginning or end of long output, and search inside text without opening a GUI editor.

Read a small file, inspect the end of a larger file, and search for one keyword without notes.

File Operations: Create and Edit

Create folders and files from the terminal, write simple text safely, and make small edits without relying on a full GUI workflow.

Create a practice folder, add two files, and write one line into each without notes.

File Operations: Copy, Move, Delete

Copy, move, rename, delete, and archive files safely so you can reorganize work without losing track of what changed.

Copy one file, rename another, and remove a practice file without deleting the wrong target.

Search and Find

Find programs and files in a way that matches the real problem: command lookup, live recursive search, or fast indexed search.

Find where one installed program comes from and locate one file by name without notes.

WSL: The Windows↔Linux Bridge

Learn how to access your Windows files from inside Linux, access your Linux files from Windows Explorer, and run commands across both OSs simultaneously.

Demonstrate this without notes: Learn how to access your Windows files from inside Linux, access your Linux files from Windows Explorer, and run commands across both OSs simultaneously.

File System Lab: Mini Scenario

Use navigation, reading, creating, moving, searching, and archiving together to clean up a safe practice project from the terminal.

Complete the scenario without using the mouse and without losing any files.

Who Owns What: Users and Groups

Understand how users, groups, and administrator-level accounts divide access so one machine can be used safely by different people and processes.

Explain users, groups, and administrator/root in your own words without notes.

Users and Groups: GUI

Inspect user accounts and group membership through graphical tools, and understand where GUI management is convenient versus limited.

Open the common account-management area for your platform and identify a user account plus its role.

Users and Groups: CLI

Inspect identities, groups, and local accounts from the command line, starting with safe read-first commands before making account changes.

Use CLI commands to identify your current user and one group membership without notes.

Permissions: NTFS and Linux rwx

Understand the basic permission models in Linux and Windows, and make small, safe permission changes without treating access control like magic.

Explain read, write, and execute in simple terms for a file and for a directory.

Elevation: UAC and sudo

Understand temporary privilege elevation in Windows and Linux so you can perform administrative work deliberately instead of staying permanently over-privileged.

Explain UAC and sudo in simple terms without notes.

Permissions Lab: Diagnose and Fix

Use a safe practice folder to inspect, break, diagnose, and restore access so permission troubleshooting feels systematic instead of scary.

Break and restore access in the practice folder without touching real system files.

Process Model: What Processes Are

Understand the difference between a program stored on disk and a process running in memory, and learn the basic ideas of PID, parent process, and thread.

Explain program versus process in your own words without notes.

Process Management: GUI

Use graphical system tools to observe process activity, spot obvious resource pressure, and end unresponsive apps more deliberately.

Open the main process view on your platform and identify a high-level resource column.

Process Management: CLI

List, filter, and stop processes from the command line with a stronger habit of inspecting before terminating.

List processes and isolate one target process without notes.

Background and Foreground

Understand how foreground work, background jobs, and persistent sessions differ so long-running commands do not surprise you or die unexpectedly.

Move a simple command between foreground and background without notes.

Performance Diagnosis

Check CPU, memory, and disk pressure more systematically so a slow system is diagnosed from evidence instead of guesses.

Name one basic check for CPU, one for memory, and one for disk activity.

Process Lab: Sluggish System

Use safe practice loads to observe a slow system, identify the cause, and restore normal behavior without guessing or overreacting.

Create and remove a harmless process load without notes.

Storage Architecture

Understand how disks, partitions, filesystems, and mount points fit together so storage changes make sense before any formatting or mounting commands are used.

Explain the storage stack in your own words without notes.

Disk Management: GUI

Use graphical disk tools to inspect disks and partitions safely, and understand which actions are low-risk inspection versus high-risk modification.

Open a disk-management GUI and identify at least one disk and one partition.

Disk Management: CLI

Inspect storage devices and mount points from the command line, and understand which commands are observational versus potentially destructive.

Use one inspection command on your platform to identify storage devices or mounted filesystems.

Storage Lab: External Drive Setup

Walk through the storage setup sequence conceptually and in safe practice steps so external-drive preparation makes sense before touching real data.

Explain the setup sequence for a new external drive without notes.

Network Model: How Networks Work

Understand the basic networking model of identity, local scope, routing, and name resolution so common network problems feel explainable instead of mysterious.

Explain the core networking pieces in your own words without notes.

Network Config: GUI

Inspect network settings in graphical tools and understand when a static IP is appropriate versus when DHCP should remain in control.

Open the GUI network settings and identify current address, gateway, or DNS details.

Network Config: CLI

Inspect network state from the command line and treat live configuration changes with enough caution to avoid breaking access unexpectedly.

Use one address-inspection command and one route-inspection command without notes.

SSH Foundation

Master the Secure Shell (SSH) protocol to securely connect to remote servers, and implement key-based authentication to eliminate passwords.

Demonstrate this without notes: Master the Secure Shell (SSH) protocol to securely connect to remote servers, and implement key-based authentication to eliminate passwords.

DNS Deep Dive

Inspect DNS resolution directly so you can separate naming problems from connectivity problems and understand local overrides such as the hosts file.

Resolve a hostname directly with a DNS tool without notes.

Network Diagnostics

Troubleshoot network problems layer by layer using connectivity tests, route tracing, DNS checks, and port inspection.

Describe a layered network troubleshooting sequence without notes.

Firewall: GUI and CLI

Understand what a host firewall does, inspect common firewall tools, and make only deliberate, minimal rule changes in the right context.

Explain what an inbound firewall rule is in plain language.

Network Lab: Full Connectivity Debug

Use a layered troubleshooting sequence to diagnose a broken connection without guessing, skipping layers, or changing settings too early.

Walk through a layered network-debug sequence without notes.

Software Installation Model

Understand the main software installation models so you can choose safer, more maintainable ways to install and update tools.

Explain the two main software-installation models in your own words.

Package Management: GUI

Use graphical software centers or app stores to discover, install, update, and remove software more safely than ad hoc downloads.

Find an app in a GUI software source and explain how the system would install it.

Package Management: CLI

Use command-line package managers to search, install, update, and remove software more consistently and with better automation potential.

Use a package manager to search for a package without notes.

Software Lab: Build a Toolkit

Plan and perform a small package-based toolkit setup in a way that is repeatable, reviewable, and safer than ad hoc downloads.

Describe a small toolkit setup flow without notes.

Git Basics: Version Control from CLI

Master the foundational CLI commands of Git to track changes, create distinct save states (commits), and review the history of a codebase.

Demonstrate this without notes: Master the foundational CLI commands of Git to track changes, create distinct save states (commits), and review the history of a codebase.

Scripting Foundation: Why Automate

Understand when scripting helps, how to plan a safe script, and how variables and conditionals make repetitive work reusable.

Explain, without notes, when you would script a task and when you would keep it manual.

PowerShell Essentials

Write and run small PowerShell scripts using variables, conditionals, loops, and the object pipeline.

Create a small PowerShell script that defines a variable, checks a condition, and prints a result.

Bash Scripting Essentials

Write and run small Bash scripts using a shebang, variables, conditionals, loops, and exit codes.

Create a small Bash script that uses a variable, a conditional, and one loop.

Scripting: Files & Text Processing

Use redirection, pipes, and a few core text tools to inspect, filter, reshape, and save command output.

Explain how `>`, `>>`, and `|` change the flow of command output.

Task Automation

Schedule a small script safely with Windows Task Scheduler or Linux cron, and understand when systemd timers are worth learning next.

Describe how to schedule one safe script on your current platform and how you would verify that it ran.

Scripting Lab: System Health Report

Build a small Bash or PowerShell script that records a timestamp, disk usage, memory information, and a short process summary into a readable log.

Create a small script that writes a timestamped health snapshot to a log file in your user space.

Scripting Lab: Backup Automation

Use robocopy or rsync to synchronize a practice folder, log the result, and understand why mirror operations need caution.

Describe or build a small sync workflow that copies a practice folder to a backup location and writes a log.

Containers Intro: Docker Basics

Understand the fundamental difference between Virtual Machines and Containers, and use the Docker CLI to run, manage, and network isolated applications.

Demonstrate this without notes: Understand the fundamental difference between Virtual Machines and Containers, and use the Docker CLI to run, manage, and network isolated applications.

Logging & Event Analysis

Use Event Viewer, Get-WinEvent, and journalctl to narrow system problems by time, severity, service, and recent activity.

Describe how to investigate a recent failure by time window, severity, and service or log source.

Services Management

Inspect, start, stop, restart, and enable services on Windows and Linux while using logs and status output to verify the result.

Inspect a service, change its state deliberately, and verify the result with status output or logs.

Boot & Startup

Explain the major boot stages on Windows and Linux and use a few practical tools to investigate slow or unhealthy startup behavior.

Describe the high-level boot sequence in order for a modern operating system.

System Updates & Patching

Explain a safe update workflow for Windows and Linux, apply updates deliberately, and verify whether a reboot is still required afterward.

Describe a simple patching workflow that includes preparation, installation, and verification.

Remote Access: Advanced

Use safer remote-access patterns for SSH, RDP, and PowerShell remoting, and understand why bastion hosts and VPNs reduce exposure.

Explain how you would make remote access safer on a lab server without locking yourself out.

Backup & Recovery: Full Workflow

Distinguish file backups, snapshots, and full-system recovery plans, and understand which recovery method fits which failure.

Explain when to use a file backup, a snapshot, or a full-system image.

Systematic Troubleshooting: PDIVET

Use a structured troubleshooting flow so you can define the problem clearly, gather evidence, test carefully, and verify the fix.

Walk through a troubleshooting case using a clear sequence from problem definition to verification.

Troubleshooting Lab: 5 Break Scenarios

Apply structured troubleshooting to realistic OS failures by choosing the first checks, narrowing scope, and proposing a safe next action.

For a realistic failure scenario, name the first checks you would run and explain why.

CLI Intensive 1: Navigation Speed Drill

Build fast, accurate terminal navigation habits so common filesystem work becomes fluent without sacrificing correctness.

Complete a short navigation sequence accurately without stopping to think through every path step.

CLI Intensive 2: Text Processing Mastery

Build fast, reliable pipeline habits for filtering, extracting, and counting text without losing track of what each stage does.

Build a short pipeline that filters, extracts, and counts useful values from a sample log.

CLI Intensive 3: One-Line Power

Use concise one-line commands for safe operational work while preserving dry-run habits, verification, and reversibility.

Build a useful one-liner that solves a real administrative task and explain each stage.

Capstone: The Expert Challenge

Use the command line to build, secure, verify, and document a small operating-system administration environment from a clean starting point.

Complete a small end-to-end system setup using only the CLI and verify each major step.