All paths
45 paths
Role paths 3
What a role needs to know, in the order it needs it.
- Not startedBackend engineer: from a request to a service you can runWhat a backend engineer works with every day: the runtime under the service, a request's path through the framework, the database connections and transactions it borrows, the tests that prove it works across boundaries, and what changes when a language model is one of your dependencies.18 topics · Intermediate
- Not startedFrontend engineer: from JavaScript to a fast, accessible pageWhat a frontend engineer needs underneath the framework: how JavaScript runs, how the browser turns your code into pixels and events, what makes a page accessible, fast and safe, and how to test the journeys that matter.17 topics · Intermediate
- Not startedMobile engineer: iOS and Android, side by sideThe rules both mobile platforms impose on your app, learned in pairs: a life cycle you don't control, one thread that draws, structured concurrency, declarative UI, strict limits on background work, push through the platform's own service, and a store between you and your users.17 topics · Intermediate
Skill paths 32
How a language, runtime or tool really works, one topic at a time.
- Not startedAI engineering: building with large language modelsHow to put a language model inside real software: what it actually computes, how to ask for output your code can trust, how to give it tools and documents, how to test it, and how to keep it fast, affordable and safe.12 topics · Intermediate
- Not startedAndroid: how an app really runsWhat the system does with your app once it is installed: the process it may kill at any time, the one thread that draws, how Compose redraws, where state survives, and how work, data, pushes and builds fit around that.12 topics · Intermediate
- Not startedAWS fundamentals: the building blocks and how they failThe handful of AWS building blocks most systems are made of (Regions and zones, IAM, VPC networking, compute, storage, databases, load balancers, queues and events, monitoring), what each one promises, what it costs, and the specific ways each one fails when you lean on it.18 topics · Intermediate
- Not startedCI/CD and DevOps: from commit to production safelyBuild a pipeline that tells you within minutes whether a change works, ships the exact artifact it tested, proves where that artifact came from, and rolls changes out gradually enough that a bad one reaches few users and is undone automatically.13 topics · Intermediate
- Not startedComputer science fundamentals for working engineersThe parts of a CS degree that keep turning up in production: how a CPU and its caches really run your code, how numbers and text are stored, what the OS and the network do for you, why concurrency is hard, and the limits no clever code gets past.13 topics · Beginner
- Not startedDocker: what a container really isWhat really happens when you run a container: the kernel features that fence in a process, the layered images it starts from, how to build them fast, small and safe, and how networking, storage, signals and Compose fit around it, on a Linux server and on a Mac.12 topics · Intermediate
- Not startedC# and .NET: how the runtime runs your codeWhat happens after you press build: IL, the JIT and its tiers, value and reference types, the garbage collector, Span, the async state machine, and how the generic host, ASP.NET Core and EF Core put it to work in a service.14 topics · Intermediate
- Not startedData structures and algorithms: the ones you actually useThe structures behind every Map, list, index and queue you rely on, what they really cost on real hardware, and how to tell which one a problem needs.13 topics · Intermediate
- Not startedGit: how it really stores your workSee the objects and pointers under every Git command, so merging, rebasing, undoing and force-pushing become deliberate choices instead of guesses, alone or on a team.13 topics · Intermediate
- Not startedGo: how it really runsWhat sits under a Go program: one static binary with its runtime, goroutines on a scheduler, channels and locks, how values are laid out and collected, and how net/http turns all of that into a server.13 topics · Intermediate
- Not startedGraphQL: what happens behind one endpointWhat a GraphQL server does with a query: the schema that types every field, how execution walks the selection one resolver at a time, why that invites N+1 queries and how batching fixes it, what partial data and the errors array mean, and how caching, authorisation, cost limits, federation and schema evolution work when every request goes to the same URL.12 topics · Intermediate
- Not startediOS: how an app really runsWhat iOS does with your app between launch and being killed: states, the main thread, how SwiftUI redraws, memory, Swift concurrency, and the rules for networking, storage, background work, push and shipping.11 topics · Intermediate
- Not startedJava: how the JVM runs your codeWhat happens after javac: bytecode, class loading, the JIT, the heap and its collectors, and how threads (platform and virtual) see each other's writes.12 topics · Intermediate
- Not startedJavaScript: how it really runsWhat the engine actually does with your code, from the call stack to the event loop, one picture at a time.12 topics · Intermediate
- Not startedKafka: the log at the centre of the systemHow an append-only, partitioned, replicated log works, what producers and consumer groups really guarantee, what exactly-once does and does not cover, and the operational traps (lag, rebalances, too many partitions) that come with running one.12 topics · Intermediate
- Not startedKotlin: the language under Android and the JVMWhat the Kotlin compiler turns your code into, how null safety, data classes, extensions, inline functions and sealed types work underneath, and how coroutines become state machines that structured concurrency keeps in check.13 topics · Intermediate
- Not startedKubernetes: how the cluster keeps your app runningHow Kubernetes turns a few YAML objects into a running, self-healing service: the control loops behind it, how pods are placed, rolled out and reached, how probes and resource settings keep them healthy (or take them down), and how state, security and operators fit in.13 topics · Intermediate
- Not startedLinux: what happens under your programFollow your program from the shell that starts it through system calls, files, memory and sockets to the service manager, limits and namespaces that run it in production, and know which tool answers which question when something goes wrong.12 topics · Intermediate
- Not startedMongoDB: documents, and the trade-offs they bringHow to shape documents around the way you read them, which index serves which query, what a write acknowledgement really promises, how a replica set fails over, and what changes when you add transactions, shards and change streams.12 topics · Intermediate
- Not startedNext.js: how it renders and cachesWhat Next.js does with your React tree: how the App Router maps folders to nested layouts, where the server and client boundary falls, how a route becomes a prerendered shell with streamed holes, what `use cache` and `cacheLife` store and for how long, how Server Actions and revalidation fit together, and what the build and the deployment target change.11 topics · Intermediate
- Not startedNode.js: how the server side runsWhat happens between your JavaScript and the operating system: the loop's phases, its private queues, the thread pool, streams, and threads of your own.8 topics · Intermediate
- Not startedPython: how it really runsWhat CPython does with your code, from bytecode and reference counts to the GIL, generators and the event loop, so its surprises stop being surprising.12 topics · Intermediate
- Not startedQA automation: tests that catch real bugsDecide what is worth testing and at which layer, write tests that fail for real bugs and only for real bugs, and keep a growing suite fast and trusted from the first unit test to production.12 topics · Intermediate
- Not startedReact: how it really rendersWhat happens between calling setState and seeing pixels: rendering and committing, how React matches trees, why hooks have rules, what effects and memoisation are for, and how transitions, Suspense and Server Components change where and when your components run.12 topics · Intermediate
- Not startedRedis: fast data and its trade-offsWhy Redis is fast, which data structure fits which job, and what you give up for the speed: memory limits and eviction, persistence that can lose writes, asynchronous replicas, a cluster with hash slots, and locks with caveats.11 topics · Intermediate
- Not startedRust: ownership and what it buys youHow Rust's ownership and borrowing rules give memory safety without a garbage collector, how traits, enums and iterators stay zero-cost, and how the same rules make threads and async code safe.12 topics · Intermediate
- Not startedSecurity basics every engineer needsSpot the threats in a design before you build it, handle passwords, sessions, tokens, secrets and keys the way current guidance says, recognise the OWASP Top 10 flaws in your own code, and know what to do when a secret leaks or a vulnerability is reported.16 topics · Beginner
- Not startedSpring Boot: how a request becomes a responseWhat Spring Boot does between an HTTP request arriving and a response leaving: the container that builds your objects, the proxies that wrap them, the threads, transactions and connections each request borrows, and how to see and test it all.12 topics · Intermediate
- Not startedSQL and PostgreSQL: what the database really doesWhat happens between sending a query and getting rows back: the planner and its plans, the indexes it can use, the transactions and row versions that let many writers share a table, and what changes when you add a pooler, replicas and partitions.13 topics · Intermediate
- Not startedSwift: the language under iOSHow Swift's value types, optionals, enums and protocols fit together, what some and any really mean, how closures and ownership relate to ARC, how the compiler checks concurrency, and the language features (property wrappers, result builders, macros) that SwiftUI is built from.13 topics · Intermediate
- Not startedTerraform: infrastructure as code that you can trustHow Terraform turns declarative configuration into real infrastructure: the plan and apply cycle, the state file it all depends on, how to change and refactor resources without destroying them, how to split environments and modules, how to test and police changes, and where OpenTofu fits.14 topics · Intermediate
- Not startedTypeScript: what the types really doWhat the checker actually knows, and what it can't: erased types, structural matching, inference and narrowing, unions and generics, strictness, the build, and the runtime data no type can check.11 topics · Intermediate
System design paths 10
Short routes through the library's pattern walkthroughs.
- Not startedResilience 101Keep one failing dependency from taking everything down.4 topics
- Not startedConsistency across servicesChange data in more than one place without losing or doubling anything.5 topics
- Not startedScaling outSpread load across many machines and keep them from drowning.5 topics
- Not startedEvent-driven systemsLet services react to what happened, and make long processes finish.6 topics
- Not startedAPIs and the edgeShape what clients see, and keep the contract honest as both sides change.7 topics
- Not startedFast readsServe the same answer cheaply, close to the reader, without serving it wrong.3 topics
- Not startedEvolving a system safelyReplace and change running systems without a big-bang rewrite.4 topics
- Not startedStaying up at scaleContain failures so most users never notice them.4 topics
- Not startedInside the databaseHow databases stay durable, scale reads, and share their changes.4 topics
- Not startedCoordinating servicesGet several machines to agree, take turns, or commit together.4 topics