New: Roadmaps ordered paths through our cheat sheets and flashcards, so you always know what to study next.
Explore themSee what's new on GitHubFrom how objects live in memory to how distributed systems survive a network partition.
A 14-step learning path. Follow it in order, or jump to what you need.
For self-taught developers and bootcamp grads who already write code but never got the systems and theory that usually comes bundled with a CS degree. Plan on about 7 to 10 weeks at a few hours a week, moving from how a program's abstractions map onto real hardware, through algorithms, operating systems, and networking, into the database and distributed-systems trade-offs that hold production software together. This path does not drill interview-style coding patterns and practice problems, that lives in Data Structures, Algorithms & Interviews, and it does not go deep on production database engineering like indexing and replication tuning, that lives in SQL & Relational Databases. By the end you can trace a class instance down to the memory it occupies, explain why a database's isolation level and a CPU's cache miss each cost you differently, and weigh what a distributed system gives up when a network partition hits.
Expected: comfortable writing and reading code in at least one programming language. Helpful but not required: a few months of hands-on project or professional coding experience.
Nine subjects sit ahead of you, and this is the one you can put to work today without installing a single tool: get comfortable with the class-and-object vocabulary here and step 2's dive into CPU instructions and memory addresses reads as familiar ground instead of alien machinery.
The four pillars from step 1 live somewhere physical: open this and you can finally explain why a class instance actually occupies bytes in RAM, how the CPU fetches and executes each instruction, and why a cache miss quietly slows code that looks fine on paper.
Go deeper on the stack and heap that step 2 only sketched at the hardware level: see exactly how your language decides when an object dies, whether that's manual, garbage-collected, or ownership-based, and why a leak in production takes hours to trace back to one region.
You can trace a class instance down to the bytes it occupies in memory and name which region holds it. Next up: the algorithms and math that make moving those bytes fast or slow.
Finish this section to unlock.
+100 XP
Walk the whole algorithmic toolbox in one broad pass, sorting and searching through graph traversal and dynamic programming, and you gain the vocabulary step 10's database query plans and step 14's distributed consensus algorithms both quietly assume you already have.
Pin down the logic and proof techniques that step 4's algorithms were built on but never proved: propositional logic, induction, and counting are the language every later correctness argument in this path, from deadlock proofs to CAP theorem trade-offs, quietly speaks.
Take the CPU and memory model from step 2 and watch an operating system turn it into processes, threads, and virtual memory: this is where you finally see what happens between hitting Enter on a command and a program actually running.
This is where step 6's tidy process model gets messy and stays messy for a while: race conditions and deadlocks are the classic struggle every self-taught engineer hits here, expect to reread the synchronization primitives table more than once before it clicks.
You can size up an algorithm's shape, prove a small claim by induction, and explain why two threads racing for the same lock corrupts data (a few minutes of due flashcards keeps section one's object model fresh while you're deep in kernel territory). Next up: getting machines to talk to each other over a wire.
Finish this section to unlock.
+100 XP
Shift from one machine to many: the OSI and TCP/IP layers here give you the map for every packet leaving the process you just learned to schedule in step 6, from DNS lookups to the port numbers your own backend code will bind to.
Go past the layer map from step 8 into the handshake, state machine, and congestion control that actually keep a connection alive, the detail level that separates knowing TCP exists from debugging why a connection just hung.
Apply the same discipline as step 9's protocol guarantees to data at rest: relational theory, keys, and normalization forms explain why a schema either protects your data or quietly corrupts it under concurrent writes.
Push past the ACID guarantee step 10 only named: isolation levels, MVCC, and two-phase locking show how a database keeps its promise even when hundreds of transactions from step 7's concurrent processes hit the same row at once.
You can read a packet capture layer by layer, explain what a TCP handshake is actually negotiating, and defend why a transaction's isolation level was chosen. Next up: what happens once one database becomes a hundred, spread across the planet.
Finish this section to unlock.
+100 XP
Take this if you're curious why so much of the industry moved off the relational model from step 10: NoSQL trades some of that model's guarantees for horizontal scale, and previews the CAP theorem trade-offs step 14 makes official.
Pick this up if you want to know what happens to the code from step 1 before it ever runs: lexing, parsing, and bytecode generation are why learning a new language after this stops feeling like starting over.
Bring every earlier step together here: the CAP trade-offs echo step 11's isolation levels, the replication and sharding echo step 10's schema decisions, and consensus runs on the networking layers from step 8. This is the second concept that trips almost everyone up at first, expect to revisit the CAP quadrant more than once, but crossing it is what the Computer Science Fundamentals badge certifies.
You can explain how a program's abstractions rest on real hardware, defend a database's concurrency guarantees, and weigh what a distributed system gives up when the network itself fails, that's the Computer Science Fundamentals badge, earned.
Finish this section to unlock.
+100 XP
Finish every required step, at least 70% of them genuinely done (not skipped), to earn this badge and 500 XP.