Systems

What happens once the code leaves your laptop — event loops, message brokers, databases, caching, APIs, and testing.

• The Event LoopWhy JavaScript can serve thousands of connections on one thread, what the queues actually are, and the single line of code that stops all of it.core
• Concurrency and ParallelismThe difference between doing many things at once and doing many things at the same instant — and the three ways to get the second one in a single-threaded runtime.core
• DatabasesWhat an index actually is, why the column order matters, what the isolation levels really guarantee, and the one bug that is fast in dev and fatal in production.core· indexed-lookup O(log n)· sequential-scan O(n)
• Caching and RedisWhy a cache is a hash table with a memory budget, why invalidation is the hard part, and why a cache without a TTL becomes a second database with no consistency story.core· get O(1)· zset-insert O(log n)
• Message BrokersQueues and logs, why exactly-once delivery does not exist, and how to build idempotent consumers that make it not matter.advanced
• API DesignREST's actual guarantees, why cursor pagination beats offset, and the two GraphQL bugs — N+1 and the shared DataLoader — that leak other users' data.core
• TestingWhy the pyramid is the wrong shape for a backend, why fakes beat mocks, and why a test that mocks the database passes while the query is wrong.core
• Delivery and OperationsWhy renaming a column correctly takes six deploys, why liveness and readiness checks are not interchangeable, and why you should alert on symptoms rather than causes.advanced
• The System Design ProcessWhy a box diagram is not a design, and what turns a guess at "how many servers" into a set of numbers someone else can check.core· requirements-to-numbers derived, not assumed
• Distributed SystemsWhy a network call is not a function call, what a partition actually forces you to give up, and why "the request timed out" never tells you whether it ran.core· fallacy assuming a remote call behaves like a local one
• ScalabilityWhy vertical scaling ends at a wall you can name in advance, what sharding actually costs you, and why "add more servers" is not a strategy until you know what state those servers share.core· vertical bounded by the largest machine you can rent· horizontal bounded by coordination cost between nodes
• Distributed TransactionsWhat a transaction spanning two services actually means when there's no shared lock, why a saga is not a transaction with extra steps, and the actions you cannot undo once they've happened.core· 2pc blocks on coordinator failure· saga no isolation between steps
• Consensus and CoordinationWhy a cluster can't tell a slow node from a dead one, how that single fact forces the quorum rule, and why a lock built on a cache expiring after a timeout is not a lock.core· quorum majority — derived from indistinguishability, not chosen by convention