DSA & System Design

System design · CS fundamentals

What is really happening underneath

Interviewers ask what a context switch costs, why TCP slows down, and what a transaction promises. Learn the mechanism behind each answer, then check yourself with a quiz.

  • 12 lessons · 5 h
  • 3 areas
  • 36 skills
  1. 1AnswerSay the idea in one sentence before you explain how it works.
  2. 2MechanismDraw what actually happens: the bytes, the pages, the locks, the log.
  3. 3Trade-offName what the design gives up, and when you would pick the other one.
  4. 4Follow-upPractise the next question the interviewer asks, then take the quiz.

1. Operating systems and concurrency

  1. 01 20 min

    Processes, Threads and Context Switches

    What a process owns, what threads share, and what the CPU actually does when it switches between them.

    Lesson 1
  2. 02 25 min

    Scheduling and Memory: Virtual Memory, Paging and the TLB

    How the OS picks who runs next, and how every process gets its own private address space through paging.

    Lesson 2
  3. 03 25 min

    Locks, Semaphores and Deadlock

    Race conditions, the three tools that tame them, and deadlock: its four conditions and the cheap ways to prevent it.

    Lesson 3
  4. 04 25 min

    Concurrency in Practice: Pools, Queues, Atomics and the Event Loop

    The building blocks real systems use: sized thread pools, bounded queues, compare-and-swap, and when an event loop beats threads.

    Lesson 4

2. Networking

  1. 05 20 min

    The Request Journey: DNS, TCP, TLS and HTTP

    What happens between typing a URL and the first byte back: DNS, the TCP handshake, TLS, and how HTTP/1.1, 2 and 3 differ.

    Lesson 5
  2. 06 25 min

    TCP in Depth: Flow Control, Congestion Control and Loss

    How TCP keeps data ordered and the network healthy: windows, slow start, retransmission, head-of-line blocking and TIME_WAIT.

    Lesson 6
  3. 07 20 min

    HTTP and API Styles: Caching, REST, gRPC and GraphQL

    What HTTP methods, status codes and caching headers promise, and when to pick REST, gRPC or GraphQL.

    Lesson 7
  4. 08 25 min

    Sessions, JWT, CORS, Load Balancers and Proxies

    Where identity lives (cookies, sessions, JWT), what CORS really restricts, and how L4 and L7 balancers and proxies sit in front of servers.

    Lesson 8

3. Databases internals

  1. 09 25 min

    Indexes: B-trees, LSM-trees and Query Plans

    What an index costs, how a B-tree and an LSM-tree each find and store data, how composite and covering indexes work, and how to read a plan.

    Lesson 9
  2. 10 25 min

    Transactions: ACID, Isolation Levels, MVCC and Locks

    What each ACID letter is built from, the anomalies isolation levels allow, how MVCC and locks work, and why write skew needs serializable.

    Lesson 10
  3. 11 20 min

    Storage Engine: WAL, Checkpoints and Crash Recovery

    Why databases log before they write, how a commit becomes durable, what recovery replays, and how the same log drives replication.

    Lesson 11
  4. 12 20 min

    Schema Design, Normalization and Joins

    Store each fact once, copy it on purpose when reads demand it, and understand how nested-loop, hash and merge joins pay for the match.

    Lesson 12