Operating Systems for MAANG Interviews

If this were a book, this page is the table of contents. Each Part below is a chapter; each chapter links out to the concepts, designs, and platform notes that already exist elsewhere in this wiki instead of duplicating them. Unwritten chapters are listed as Planned rows, not empty files.

The progression follows how operating systems evolved historically and how interviewers typically expect candidates to reason about OS internals — first principles through advanced concurrency and kernel concepts, with extra depth in Linux internals, containerization, and observability for SRE / Platform / Infrastructure Engineer interviews specifically.

Parts

00 — Foundations

The mental model of what an operating system actually is: why it exists, how the boot process gets a kernel running, and the vocabulary (kernel space, system calls, ABI/API) that every later Part builds on.

• 1 — What is an Operating System? — (stub)
• 2 — Computer Architecture Essentials — (stub)
• 3 — OS Interfaces — (stub)

01 — Processes

The process abstraction — how one is born, how it becomes another program, how the kernel switches between processes, and how independent processes talk to each other.

• 1 — Process Fundamentals — (stub)
• 2 — Process Creation — (stub)
• 3 — Context Switching — (stub)
• 4 — Interprocess Communication — (stub)

02 — Threads

Threads as the unit of execution inside a process — lifecycle, creation models, and the primitives used to coordinate multiple threads safely.

• 1 — Threads — (stub)
• 2 — Multithreading — (stub)
• 3 — Synchronization Primitives — (stub)

03 — Concurrency

What goes wrong when synchronization primitives are used incorrectly — races, deadlocks, the classical problems interviewers reuse to test reasoning, and the memory-ordering rules underneath. See Lock-Free Programming and Threading Patterns for the application-level design patterns built on top of these primitives.

• 1 — Race Conditions — (stub)
• 2 — Deadlocks — (stub)
• 3 — Classical Synchronization Problems — (stub)
• 4 — Memory Ordering — (stub)

04 — CPU Scheduling

How the kernel decides what runs next — from textbook algorithms to Linux’s actual CFS implementation. See Processes, Threads, and Scheduling for the Linux CFS scheduler from an SRE/production-debugging angle — not to be confused with the Kubernetes pod scheduler covered under Scheduler Internals, which places pods onto nodes rather than threads onto CPUs.

• 1 — Scheduling Fundamentals — (stub)
• 2 — Scheduling Algorithms — (stub)
• 3 — Modern Scheduler Design — (stub)

05 — Memory Management

Address spaces, paging, virtual memory, and the allocators that back malloc() — the layer that turns physical RAM into the illusion every process gets its own. See Memory Management for why “out of memory” in Kubernetes is rarely about the number top reports.

• 1 — Memory Fundamentals — (stub)
• 2 — Paging — (stub)
• 3 — Virtual Memory — (stub)
• 4 — Page Replacement — (stub)
• 5 — Memory Allocation — (stub)

06 — File Systems

How files, directories, and metadata are actually laid out on disk, and how modern filesystems add journaling and copy-on-write for crash safety. See Filesystems and Storage for how the page cache and I/O scheduler interact with this layer in production, and Disk Performance for the IOPS/throughput framing.

• 1 — File System Basics — (stub)
• 2 — File System Internals — (stub)
• 3 — Storage Management — (stub)

07 — Input / Output

Blocking vs. non-blocking I/O and the event-driven multiplexing APIs (epoll, io_uring) that let a single thread serve thousands of connections — the mechanism underneath every high-performance web server and proxy.

• 1 — I/O Architecture — (stub)
• 2 — Event Driven Systems — (stub)

08 — Security

The kernel-enforced boundaries that keep one user or process from touching another’s data — permissions, capabilities, and mandatory access control. See SELinux, AppArmor, Capabilities, and Seccomp for these same primitives explained through the Kubernetes securityContext lens; Linux Fundamentals and Linux Kernel Isolation for namespaces/cgroups as the container isolation mechanism.

• 1 — Operating System Security — (stub)
• 2 — Isolation — (stub)

09 — Linux Internals

The Linux-specific implementation details and diagnostic toolkit interviewers expect for SRE/Platform/Infrastructure roles. See Linux Internals Every SRE Must Know and Linux Troubleshooting for the syscall/VFS/scheduler mental model and the strace/perf/proc toolkit already written up from an incident-response angle, and What is eBPF for the eBPF foundations this Part’s Linux Performance chapter builds on.

• 1 — Linux Kernel Overview — (stub)
• 2 — Linux Process Management — (stub)
• 3 — Linux Performance — (stub)

10 — Distributed Systems Perspective

How the single-machine OS abstractions from earlier Parts get virtualized, containerized, and orchestrated at cluster scale. See Virtual Machines for hypervisor-level isolation, and Node Monitoring / eBPF-Based Observability for how these OS-level signals get surfaced as telemetry.

• 1 — OS in Cloud Computing — (stub)
• 2 — Operating Systems for Kubernetes — (stub)
• 3 — Operating Systems for Observability — (stub)

11 — Advanced Topics

Kernel-level concurrency and I/O techniques past the interview-fundamentals bar — useful for L6+ infrastructure and platform roles. See Lock-Free Programming for CAS/atomics/wait-free queues from the application-design-pattern angle; this Part’s chapter goes kernel-side instead (RCU, spinlocks, seqlocks).

• 1 — Lock-Free Programming — (stub)
• 2 — NUMA Systems — (stub)
• 3 — Kernel Synchronization — (stub)
• 4 — High Performance I/O — (stub)
• 5 — Emerging Operating System Technologies — (stub)

12 — Interview Preparation

Where OS internals meet the whiteboard — classic problems, system-design connections, and Linux-specific interview questions, synthesized into an L4–L6 masterclass.

• 1 — Classic Interview Problems — (stub)
• 2 — System Design Connections — (stub)
• 3 — Linux Interview Questions — (stub)
• 4 — MAANG Interview Masterclass — (stub)

Suggested Study Order (Highest ROI)

1. 00 — Foundations
2. 01 — Processes
3. 02 — Threads
4. 03 — Concurrency
5. 04 — CPU Scheduling
6. 05 — Memory Management
7. 06 — File Systems
8. 07 — Input / Output — I/O multiplexing (epoll, io_uring)
9. 09 — Linux Internals
10. 10 — Distributed Systems Perspective — OS in cloud & Kubernetes
11. 11 — Advanced Topics, Chapter 1 — Lock-Free Programming
12. 12 — Interview Preparation — interview problems & mock interviews

This sequence aligns with MAANG interview expectations for L4–L6 software engineering roles, with additional depth in Linux internals, containerization, and observability that is particularly valuable for SRE, Platform Engineering, and Infrastructure Engineering interviews.

Metadata

Author	Amit Singh
Scope	operating-system