Everything you can learn here
A real, hands-on curriculum — browse what each skill covers before you sign up.
Linux systems
Shell
Pipes, redirection, scripting — turning repetitive tasks into one-liners.
Storage on Linux
Partitioning tools, LVM, software RAID, filesystem creation and mounting, and real backup scripting — the hands-on Linux counterpart to Storage: The Foundations.
Linux
Filesystems, permissions, processes, and the shell habits that make everything else faster.
Virtualization
What a hypervisor actually does, running real virtual machines with KVM/QEMU, and the clear line between a VM and a container before you meet Docker.
High Availability: The Concepts
Why systems fail, how uptime is actually measured, and the redundancy patterns that keep a service running when a piece of it breaks.
High Availability on Linux
Put the HA concepts into your hands: keepalived and VRRP for failover IPs, HAProxy for real load balancing, Pacemaker/Corosync clustering, DRBD replication, and building a real failover-ready service.
Advanced Linux
Processes, systemd, and performance under the hood.
Linux Administration
Real sysadmin work: packages, users, firewalls, SSH, backups, and troubleshooting.
Automation & Scripting
Turn repetitive shell commands into real scripts with logic — loops, conditions, and reusable tools.
Common core
Fundamentals
How a computer and a server actually work, before you touch a terminal.
Computer Math
Binary, hexadecimal, boolean logic and the IP address arithmetic every operator ends up doing on a napkin.
Operating Systems
Processes, memory, files, drivers, boot — what every OS does under the hood, before you commit to one.
Algorithms & Data Structures
How to think in steps a machine can follow, and the handful of structures that carry all of computing.
Data & Applications
How software actually stores and moves information — files, databases, APIs, JSON.
Cloud & SRE
Cloud Fundamentals
IaaS/PaaS/SaaS, shared responsibility, regions, elasticity — what the cloud actually is.
Infrastructure as Code
Stop clicking buttons and typing commands by hand. Describe your infrastructure as text, version it, and let a tool make reality match it.
CI/CD Pipelines
Automate the path from a code change to a running system in production: build, test, and deploy without a human doing it by hand every time.
Observability
A system running in production is a black box until you instrument it. Logs, metrics, and traces are how you see inside it, and alerting and SLOs are how you decide when to act.
Databases & data
Databases: The Foundations
How structured data is really organized, and why it works this way.
SQL in Practice
The language every relational database speaks — reading, filtering, joining, and changing data with precision.
Administering PostgreSQL
Keeping a real, running database alive — installation, users, backups, restores, replication, and the tuning that keeps it fast under load.
NoSQL Databases
When a relational table isn't the right shape — document, key-value, and wide-column databases, and the real tradeoffs behind choosing one.
Data Engineering
Pipelines, ETL/ELT, batch vs streaming, and moving data reliably at scale.
Expert (optional)
Kubernetes: Operators & Beyond
Extend Kubernetes itself: operators, CRDs, service mesh, advanced scheduling.
Kernel Internals
What is actually happening below the shell you have been living in.
Distributed Storage
Ceph, advanced ZFS, and the real tradeoffs of storage at scale.
Database Systems at Scale
Optional, elite-tier: the techniques that keep a database fast and correct once it outgrows a single machine and a handful of users — advanced indexing, partitioning, sharding, and the OLTP/OLAP split.
OS Development Basics
Start from absolute zero, no operating system at all, and build up to code that boots and runs.
Digital Forensics
Evidence acquisition, chain of custody, and incident reconstruction — optional deep dive.
Building a Kernel
Go from reading about the kernel to actually compiling one yourself.
Ethical Offensive Security
Authorized penetration testing methodology, from scoping to reporting — optional, ethics-first.
Distributed Systems
CAP, consensus, message queues, and the real problems of systems that span machines.
Containers From First Principles
Docker taught you the commands. This is what actually happens underneath: namespaces, cgroups, and why a container was never a lightweight virtual machine.
eBPF
Run safe, sandboxed programs inside the kernel itself, without writing a kernel module.
Kernel Modules
Write, compile, and load your own piece of code directly into the running kernel.
Network Expert
BGP, OSPF, VPNs, packet analysis, and real troubleshooting methodology.
AD Expert
Forests, Kerberos internals, advanced GPO, and hardening Active Directory.
Serving AI in Production
What it actually takes to run a model reliably at scale.
Development
How the Web Works
HTTP, DNS, HTML/CSS/JS, and what actually happens between typing a URL and seeing a page.
C
Memory, pointers, and the language the OS itself is written in.
Git
Version your work like every professional team on Earth: commits, branches, merges, remotes — and how to undo mistakes.
Networks
Networking
Subnetting, routing, and firewalls — how packets actually get where they are going.
Network Services
DNS, DHCP, HTTP, and mail — the application-layer services that make a working network actually useful, in depth.
Networking on Linux
ip, nftables, VLANs, and bonding — configuring and defending a real network stack on a real Linux machine, hands-on.
Cybersecurity
Security: The Foundations
Threats, defenses, and the mindset that keeps systems and people safe.
Web Security
OWASP, injections, XSS, broken auth — understanding attacks to build real defenses.
Cryptography
From Caesar ciphers to TLS — how secrets actually stay secret, made rigorous and accessible.
Hardening Linux Systems
Turn a default Linux install into one that resists real attackers: SSH keys, sudo, firewalls, fail2ban, mandatory access control, and permissions as a security tool.
Defense & Detection
SOC operations, logging, SIEM, and the incident response lifecycle.
Software engineering
Artificial intelligence
AI: How It Actually Works
Cut through the hype and learn what AI, machine learning, and deep learning really are.
The Math of AI
Vectors, gradients, and probability — the concrete intuition behind every model.
Machine Learning in Practice
From raw data to a working prediction — the full ML pipeline, hands-on.
Neural Networks
From a single neuron to the architectures that power modern AI.
LLMs, Embeddings & RAG
What large language models actually do, and how to ground them in real data.
Platform
Windows / AD
PowerShell
The object pipeline, cmdlets, and real scripting on Windows.
Windows Fundamentals
How Windows actually works under the hood — architecture, registry, services, filesystem.
Windows Server & Active Directory
Domains, AD objects, Domain Controllers, DNS, Group Policy — running a real Windows network.
Create a free account and begin your first quest — no card required.
Start free