0% completed
Course Introduction
On This Page
Who This Course Is For
The Checkout Service
How the Lessons Work
The Chapters
A backend service can pass every test and still fail in production. It can run out of ports while its CPU is idle, return 502 errors only at low traffic, or lose orders that it had already confirmed after a crash. None of these failures starts in the application code. Each one starts lower down, in the operating system or the network.
This course teaches that lower part of the system. It explains what the Linux kernel and the network do for every request a backend service handles, and it shows how to find which layer is at fault when the service misbehaves.
Who This Course Is For
The course is written for backend engineers with one to six years of experience. You write services in Java, Go, Node.js, or Python, and you deploy them to Linux servers, either directly or inside containers. You can run commands in a shell, read a short Python program, and follow a log file.
No knowledge of kernel internals is assumed. Every term is defined where it first appears. That includes familiar terms that are rarely explained, such as a file descriptor, a socket, or a page fault. The course does not teach you to write a kernel, drivers, or network routing software. Linux is the only platform covered in depth.
The Checkout Service
Every lesson follows one service. Checkout is the order service of an online store: it receives an order over HTTPS, saves it in a Postgres database, and charges the customer through an external payment provider. It runs on Linux virtual machines behind a load balancer, and its database runs in the same data center.
Following one service has a purpose. A single request to Checkout passes through the network card, the kernel's network code, a socket, a process, memory, a disk, and several remote connections. Each chapter studies one of those stops in detail, so by the end you have seen the whole path of a real request, one layer at a time.
How the Lessons Work
Each lesson opens on something concrete, such as a command's output, a measured number, or a symptom from production. It then explains the mechanism in plain language. Diagrams show the steps that are easier to see than to read.
Every number and every command output comes from a real run on Linux. The demos for each lesson ran on a cloud virtual machine with Linux kernel 7.0, and the lesson shows their output exactly as it was printed. When a measured cost appears in the text, such as 145 nanoseconds for a system call, it comes from that lesson's run. Numbers from different runs, and on your own servers, will differ somewhat. Their order of size will not. When a behavior could not be reproduced on that machine, the lesson says so plainly instead of showing invented output.
Most demos use small Python or C programs built from the standard library, together with standard Linux tools such as ss, strace, and /proc. You do not need to run them yourself; the lessons show what they printed and explain each line.
Each concept lesson also has three fixed parts near its end:
- In Production. The symptom that the mechanism causes on a real service, how that symptom looks, and the command that reveals it. These sections are the reason for the course: they connect each mechanism to a problem you can recognize and diagnose.
- Key Takeaways. Five or six short statements of what the lesson established.
- Practice Questions. Four or five questions with folded answers. Try each one before you open its answer.
Some lessons cover topics that engineers are often asked about in interviews. Those lessons add a short section with one sample answer and two common follow-up questions. Chapters 1 to 14 each end with a quiz that draws 10 questions from a bank of 20, and the review chapter ends with a final exam.
The Chapters
| Chapter | What it covers |
|---|---|
| 1. One Request Through the Machine | One Checkout order from the network card to the handler and back, and what each step costs |
| 2. Processes and System Calls | The boundary between a process and the kernel, what a process owns, workers, threads, signals, and containers |
| 3. CPU and Scheduling | How the scheduler shares CPUs, context switches, load average, worker counts, and CPU quotas |
| 4. Memory | Virtual memory, what "memory used" means, garbage collected runtimes, swap, and the OOM killer |
| 5. Files and Storage | File descriptors, the page cache, what fsync promises, logs, disks, and full disks |
| 6. I/O Models | Blocking and nonblocking I/O, epoll, event loops, io_uring, and zero copy |
| 7. IP Networking for Backend Engineers | Packets, ports, subnets, NAT, MTU problems, binding addresses, and network namespaces |
| 8. TCP in Depth | The handshake, retransmission, flow and congestion control, Nagle's algorithm, closing, ports, and keepalives |
| 9. Sockets and the Kernel | listen, accept, and connect, the accept queue, socket buffers, and connection pools |
| 10. UDP and QUIC | What UDP leaves out, head of line blocking, and how QUIC rebuilds TCP's jobs |
| 11. DNS and TLS in Production | Name resolution inside a service, DNS caching and failures, the TLS handshake, and certificates |
| 12. Load Balancers and Proxies on the Wire | Layer 4 and layer 7 balancing, the timeout chain, health checks, and the real client address |
| 13. Observing a Linux Server | A method for performance problems and the tools for CPU, memory, disk, network, system calls, and packets |
| 14. Production Incidents | Seven incidents on Checkout, each traced from symptom to cause with the tools from earlier chapters |
| 15. Review | The path of one URL through the kernel, and common operating system and networking questions |
The chapters build on each other. The operating system comes before the network, because a socket is read through the same file descriptors and buffers as a file. TCP comes before sockets, because the kernel's connection queues only make sense once the handshake is clear. The tools come after the mechanisms, so that each command's output has a meaning when you first read it. The incidents come last, because each one combines several chapters.
The first lesson, One Request, Step by Step, follows a single Checkout order through a real Linux server and names every place where it can wait.
Reading Progress
0%
On This Page
Who This Course Is For
The Checkout Service
How the Lessons Work
The Chapters