← All tracks
CS foundations & interview prep
Evergreen, and the backbone every other track links into.
- 0%Computer ScienceThe layers above data structures and algorithms (see datastructures-and-algorithms) and short of system design (see system-design): how a CPU actually executes a program, how an operating system shares one machine among many programs, what a computer can and can't compute and how a compiler turns text into something that runs, how concurrent code stays correct, how bits become numbers and text, how patterns organize software, and how machines talk to each other over a network. Twenty-nine lessons that assume the core data structures and algorithms as a starting point.Lesson groups
- Representation & caching
- Computer architecture
- Operating systems
- Theory of computation & compilers
- Concurrency & practices
- Design patterns & architecture
- +1 more
- 0%Data Structures & AlgorithmsComplete on its own: the core data structures and algorithms from the ground up (complexity, arrays/lists/stacks/queues, hash tables, trees and heaps, graphs, sorting, searching, recursion, greedy, backtracking, dynamic programming), then everything computer-science doesn't cover — advanced trees and range-query structures, disjoint sets and graph-structure algorithms, shortest-path algorithms that handle negative weights and heuristics, non-comparison sorting, the design techniques behind divide-and-conquer and randomization, advanced string matching, and the full interview pattern catalog: two pointers, sliding window, merge intervals, cyclic sort, top-k/two-heaps, subsets and permutations, classic DP, and the rest of what LeetCode-style problems are actually built from.Lesson groups
- Complexity & math foundations
- Core data structures
- Sorting, searching & recursion
- Graph algorithms
- Algorithm design paradigms
- Advanced linear structures
- +12 more
- 0%System DesignHow a system is actually designed to handle scale: the estimation and tradeoff habits, the networking and API choices, load balancing, caching, data modeling and storage at scale, consistency/availability/consensus, asynchronous messaging, reliability patterns, architecture patterns, and observability and security at scale that a production system needs — closing with worked, end-to-end case studies of the classic system-design interview problems. Sixty lessons that assume the core data structures and algorithms, and general computer science, as a starting point (see datastructures-and-algorithms and computer-science).Lesson groups
- Design fundamentals & estimation
- Networking, APIs & communication
- Load balancing & service discovery
- Caching at scale
- Data modeling & storage
- Scaling data & services
- +6 more
- 0%Software ArchitectWhat the architect role actually does above the code: making and recording trade-off decisions, the principles and patterns that keep a system coherent as it grows, the paradigms an architect has to reason across, security and data architecture, and the cloud and enterprise patterns a production system is actually assembled from. Twenty-six lessons that assume computer-science and system-design as a starting point and go one layer up from both — the job of choosing and defending a system's shape, not the mechanics of any one piece of it.Lesson groups
- The architect role
- Principles & patterns
- Paradigms
- Security architecture
- Data & integration architecture
- Cloud & enterprise patterns
- 0%API DesignHow to design, secure, document, and operate an API as a product with its own contract — not the transport or infrastructure underneath it. Resource modeling, versioning, pagination, and error contracts; OAuth2/JWT/API-key authentication and the full authorization-model taxonomy in practice; OpenAPI documentation and a testing discipline built specifically for APIs (contract tests, mocking, load testing); the OWASP API Security Top 10; and the compliance standards an API has to answer to. Twenty-one lessons that assume computer-science (HTTP, TCP/IP, DNS) and system-design (REST/gRPC/GraphQL mechanics, rate limiting, caching, load balancing, gateways, event-driven messaging, microservices) as a starting point and go one layer up — the contract a client depends on, not the mechanics underneath it.Lesson groups
- Designing the contract
- Real-time & integration patterns
- Authentication & authorization
- Documentation, testing & quality
- Security, performance & compliance
- 0%Design Principles & PatternsThe heuristics that keep a design honest as it grows — DRY, KISS, YAGNI, composition over inheritance, coupling and cohesion — the discipline of noticing and fixing a design that's gone bad (code smells, refactoring, test-driven development), and the Gang-of-Four catalog of creational, structural, and behavioral design patterns as the recurring shapes those heuristics produce in practice. Fifteen lessons that assume object-oriented programming and SOLID as a starting point (see software-architect) and go one layer deeper than computer-science's single GoF survey lesson into the patterns themselves.Lesson groups
- Design principles
- Code quality in practice
- Creational patterns
- Structural patterns
- Behavioral patterns
- 0%Code ReviewThe craft of peer review itself — not the design judgment a reviewer applies (that's `software-design-architecture`/`software-architect`), but the practice around it: why review earns its cost, preparing a change so it's actually reviewable, what a reviewer should spend attention on, the etiquette of giving and receiving feedback without it turning adversarial, pushing the mechanical checks onto tools instead of people, and the failure modes (bikeshedding, rubber-stamping, review fatigue) that show up once a team does this every day.Lesson groups
- The practice of review
No roadmap matches that filter — try clearing it.