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.

Level:
Beginner
Study Time:
23h
Lessons:
95
Assessments:
155
Updated
Yesterday
4.6
(339 ratings)
1,591 learners
Arslan Ahmad
Created byArslan Ahmad
Ex FAANG Manager, Expert Behind Grokking Operating Systems and Networking for Backend Engineers

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.

Grokking Operating Systems and Networking for Backend Engineers Image
This course
Lifetime access to this course
One-time payment. Yours forever.
All 72 courses
Annual plan
Discussions
Certificate
Free updates
Own everything, once
Grokking Operating Systems and Networking for Backend Engineers Image
This course
Lifetime access to this course
One-time payment. Yours forever.
All 72 courses
Annual plan
Discussions
Certificate
Free updates
Own everything, once

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

• 16 Chapters • 95 Lessons
1.

Introduction

1 lesson

Course Introduction

One Request, Step by Step

Where the Time Goes in a Request

Quiz: One Request Through the Machine

What people say about our courses

Arijeet avatar
Arijeet
Software Engineer
Just completed the “Grokking the system design interview”. It's amazing and super informative. Have come across very few courses that are as good as this!
Ashley Pean avatar
Ashley Pean
Software Engineer
Check out Grokking the Coding Interview. Instead of trying out random Algos, they break down the patterns you need to solve them. Helps immensely with retention!
Steven Zhang avatar
Steven Zhang
Software Engineer
Just wanted to say thanks for your Grokking the system design interview resource (https://lnkd.in/g4Wii9r7) - it helped me immensely when I was interviewing from Tableau (very little system design exp) and helped me land 18 FAANG+ jobs!
Eric avatar
Eric
Software Engineer
I've completed my first pass of "grokking the System Design Interview" and I can say this was an excellent use of money and time. I've grown as a developer and now know the secrets of how to build these really giant internet systems.
Roger Cruz avatar
Roger Cruz
Software Engineer
The world gets better inch by inch when you help someone else. If you haven't tried Grokking The Coding Interview, check it out, it's a great resource!
Simon Barker avatar
Simon Barker
Software Engineer
This is what I love about http://designgurus.io’s Grokking the coding interview course. They teach patterns rather than solutions.

About the Author

Arslan Ahmad

Arslan Ahmad

Design Gurus Founder
Ex-FAANG Manager
Meta
Microsoft
Google
Amazon
Uber

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

Grokking System Design Fundamentals
Learn system design from scratch: scalability, load balancing, caching, databases and the CAP theorem, explained for beginners with a quiz in every chapter.
4.5
95K learners
Discounted price for Your Region

$98

Grokking Multithreading and Concurrency for Coding Interviews
Master multithreading and concurrency with practical examples to tackle race conditions, deadlocks, and coding interview challenges effectively.
3.8
2.1K learners
Discounted price for Your Region

$98

New
Grokking Kafka and Event-Driven Architecture
Learn to design event-driven systems with Apache Kafka: when to use events, how to size topics and partitions, and how to reason about durability, duplicates, ordering, and consumer lag.
4.4
668 learners
Discounted price for Your Region

$72

FAQs

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Design Gurus logo
One-Stop Portal For Tech Interviews.
About Us
Our Team
Careers
Partners
Contact Us
Become Affiliate
Copyright © 2026 Design Gurus, LLC. All rights reserved.