Grokking Operating Systems and Networking for Backend Engineers
Learn what Linux and the network do with every request your service handles, from processes and memory to TCP, DNS, and TLS, and how to find the layer at fault. Every output shown comes from a real Linux run.

Course Overview
This course follows the requests of one backend service, an order service called Checkout, through the operating system and the network. Each lesson explains one mechanism, such as the accept queue, the page cache, fsync, epoll, the TCP congestion window, or TIME_WAIT, and then shows the problem it causes in production and the Linux command that reveals it. Every command output in the course comes from a real run on a Linux server. The course ends with production incidents worked from the first symptom to the root cause.
What you'll learn in Grokking Operating Systems and Networking for Backend Engineers
- Follow one request from the network card to your handler and back, and see where it can wait.
- Read what a process owns, from file descriptors to memory, and why a container is still a process.
- Read load average, CPU usage, and CPU throttling correctly, and size worker pools from them.
- Know what fsync promises, why databases write a log first, and why deleting a file may free nothing.
- Debug TCP: the handshake, retransmission, congestion control, Nagle, TIME_WAIT, and port exhaustion.
- Find DNS and TLS problems in production, from cached old addresses to missing intermediate certificates.
- Use ss, strace, tcpdump, perf, and eBPF tools to find which layer is at fault.
- Estimate what system calls, context switches, disk writes, and network round trips cost.
- Shut services down gracefully with signals, and read exit codes such as 137 and 143.
- Explain what "memory used" really means, why servers slow down under swap, and when the OOM killer acts.
- Compare blocking I/O, epoll event loops, io_uring, threads, async await, and goroutines.
- Read the accept queue, socket buffers, and connection pools, and see why new connections are expensive.
- Trace timeouts and health checks through load balancers, and find the real client address.
- Work real incidents from the first symptom to the root cause, one layer at a time.
Course Content
One Request Through the Machine
TCP in Depth
The Three Way Handshake and What It Costs
Sequence Numbers, Acknowledgments and Retransmission
Flow Control and the Receive Window
Congestion Control From Slow Start to BBR
Nagle's Algorithm and Delayed ACKs
Closing Connections and the Time Wait State
Ephemeral Port Exhaustion
Keepalives, Resets and Half Open Connections
Quiz: TCP in Depth
Load Balancers and Proxies on the Wire
Production Incidents
What people say about our courses






About the Author

Arslan Ahmad
Industry Expertise & Leadership
Arslan Ahmad is the lead author of Grokking Operating Systems and Networking for Backend Engineers. As the founder of Design Gurus and a former FAANG hiring manager, he has worked at industry giants like Facebook (now Meta) and Microsoft.
He has conducted hundreds of system design interviews, giving him unique insight into what top tech companies look for in candidates.
The course also incorporates expertise from senior engineers at Google, Meta, Amazon, Microsoft, and Uber, ensuring you learn system design best practices from professionals who have built and scaled real-world systems.
500+
Interviews Conducted
10k+
Students Taught
Related Courses
$98
$98
$72
FAQs
What is Grokking Operating Systems and Networking for Backend Engineers?
It is a text course on what the Linux kernel and the network do for every request a backend service handles. Each lesson explains one mechanism, such as the accept queue, the page cache, fsync, epoll, the TCP congestion window, or TIME_WAIT, then shows the problem it causes in production and the Linux command that reveals it. The course ends with production incidents worked from the first symptom to the root cause.
Who is this course for?
It is for backend engineers who write services in Java, Go, Node.js, or Python and deploy them to Linux servers, directly or in containers. It suits engineers who have met a production problem they could not explain from the application code, such as connection timeouts with an idle CPU, and engineers preparing for interviews that ask operating system and networking questions.
What should I know before starting?
You should be able to run commands in a shell, read a short Python program, and follow a log file. You do not need any knowledge of kernel internals, because every term is defined where it first appears, including familiar ones such as a file descriptor, a socket, or a page fault.
Is this a university operating systems or networking course?
No. It teaches the parts of the operating system and the network that a backend engineer meets in production, from the side of a running service. It does not teach you to write a kernel, drivers, or routing software, and it explains each mechanism through the symptom it causes and the command that shows it.
Are the command outputs real?
Yes. Every command output and every measured number comes from a real run on a cloud virtual machine with Linux kernel 7.0, and the lesson shows the output exactly as it was printed. When a behavior could not be reproduced on that machine, the lesson says so plainly instead of showing invented output.
Do I need a Linux machine to take the course?
No. The lessons show what each demo printed and explain each line, so you can follow the course on any computer. If you have a Linux server, you can run the same standard tools, such as ss, strace, and tcpdump, on your own services.
Which programming languages does the course use?
The demos are small Python and C programs that use only the standard library, together with standard Linux tools. One lesson compares threads, async await, and goroutines with short Python, Go, and Java examples. The mechanisms are the same for any language that runs on Linux.
Does the course cover containers and Kubernetes?
It covers the kernel features that containers are built on, namespaces and cgroups, and what they mean for a service: memory limits, CPU throttling, and network namespaces. It does not teach how to configure Docker or Kubernetes.
Does it cover macOS or Windows?
No. Linux is the only platform covered in depth, because it is where most backend services run. Many of the networking ideas, such as the TCP handshake, congestion control, DNS caching, and TLS, apply on any operating system.
Is there any practice, or is it only reading?
The lessons end with practice questions whose answers you can open after trying them, every chapter from the first to the incidents chapter ends with an adaptive quiz, and the review chapter ends with a final exam that covers the whole course.
Will this course help with interviews?
Lessons on topics that interviewers often ask about, such as processes and threads, the TCP handshake, or what happens when you type a URL, end with a short section that gives a sample answer and two common follow-up questions. The review chapter collects common operating system and networking questions with answers.
Is the course text-based or video-based?
It is text-based, with animated diagrams that show requests, packets, and data moving through the system, so you can read at your own pace and return to any lesson as a reference when a production problem comes up.