CrackingWalnuts
The homepage shows you the road your career takes. This is the road this platform has taken: the courses, the deep dives, and the product we built to hold them, dated and newest first. Nothing is backdated, and nothing is here that is not live.
Last shipped Oct 16, 2026 — System Design: Uber (25M Rides/day, H3 Driver Index, Batch Matching, Exactly-Once Dispatch)
Design Uber for 25 million rides a day. A measured H3 driver index in Redis, batch matching that beats nearest-driver, a location path that never moves a driver backwards, dispatch that never promises one driver to two riders, exactly-once payments, surge with legal caps, what happens when each part goes down, regions, capacity and cost.
Design a news aggregator like Google News for 100,000 sources and 50 million daily users. A crawl schedule that survives crashes, four layers of duplicate detection from exact copies to the same event in different words, ranking stories with a key that never needs updating, breaking news per story, measured sizing, failures, bottlenecks and regions.
Design a news feed for 500 million daily users. Push, pull and hybrid fan-out with the maths, a write path that can't lose a post, a read path that loads a user's state in one call, two-stage ranking, measured Valkey sizing, what happens when each part goes down, bottlenecks, regions and cost.
Design a distributed rate limiter for 1M decisions a second. Eight algorithms with worked examples, tested Valkey Lua scripts, how to set up the Valkey cluster, a rule engine, what happens when each part goes down, bottlenecks, analytics, cost, and what breaks at 10x and 100x.
9 new patterns, including LFU Cache, Eulerian Path, Stack Basics and Randomized Algorithms, bring it to 81 in 15 families. Every worked example is now drawn one step at a time, 467 interview problems are mapped, and you can type a phrase from any problem to find its pattern. Sliding Window is free.
Read one chapter freeFourteen more families: vector databases, object storage, realtime delivery, traffic routing, stream processing, durable workflows, coordination, warehouses, realtime OLAP, time series, graph databases, architecture styles, unique ids and multi-region data. All twenty-one now show how each product is built, what happens when it fails, and where its guarantees stop.
Seven families: caches, message queues, relational databases, distributed key-value stores, distributed SQL, search engines and document databases. Each page takes one problem from an online shop, draws it once per product, and shows what would change the choice.
Nine code quality numbers, each worked out by hand on one JavaScript function and then checked against the tool. Coverage is only the first of them.
Seven change requests reach the same small shop. Each one is hard to make, a design principle explains why, the fix is made, and a code quality number changes. Every number comes from a tool run.
How repeating the same Transformer layers can help, why the model needs training for it, and what extra passes cost in time and memory.
Blockchain data structures, Bitcoin, Ethereum, consensus, rollups and ZK, taught as systems engineering.
Read one chapter freeA first-principles reference design for a Durable-Object-style runtime: one SQLite database per object, ETag compare-and-swap for ownership, one node lease instead of one lease per object, epochs as fencing tokens, route caches, and lazy failure recovery.
How a 284B-parameter Mixture-of-Experts model decodes on a consumer GPU: attention, FFNs, routers, and how FreeToken runs cache misses either on the CPU or on the GPU after transferring their weights.
How an LLM really runs on Kubernetes: vLLM pods, KV and prefix caching, tensor parallelism across four GPUs, llm-d routing, prefill/decode disaggregation.
Design an LLM inference platform for a 70B model at 10,000 requests a second, 25,000 at peak. Why prompt processing decides the fleet size, how prefix-aware routing and a CPU cache tier save GPUs, when to split prefill and decode, admission by tokens, failures, operations and the cost per request.
Design the safety pipeline for a chat and agent platform at 25,000 requests a second. A guard cascade keeps about 57 GPUs busy instead of 311. Answers are checked as they stream, and tools stay safe when the model is fooled. Thresholds come from base rates, and each failure has a planned response.
Design the platform that decides whether a new model release ships. It covers test size, judges you can trust, paired statistics and gates that people can stop. It also covers private test sets, checks after launch, failures, scaling and cost.
Design the stack that pre-trains a 70B model on 15 trillion tokens with 1,024 B200 GPUs in FP8. It covers the split, one step, memory and failures. The run takes about 58 days and $13.4M.
Design one platform for a home feed's models at 20,000 requests a second, with fraud and image models beside it. It runs two-tower retrieval with ANN search, a pre-ranker and a GPU ranker over 500 items. We pick CPU or GPU for each model from its maths. Then we cover feature reads and releases, then failures and a cost of about $66K a month.
DeepSeek Harness uses Cordis to load, connect, and remove plugins while the program is running. This guide explains the paper behind that design with a failing-test example.
Text has no pixels to hide a pattern in, and a watermark that survives copy and paste is not metadata. The signal can live in the choices a model makes while picking each word. Here is how green and red token lists, entropy thresholds, and semantic watermarks actually work.
Bookmarks, per-chapter notes, and progress you can pick back up on any device.
A research system called HTTP Terminator turned 138 protocol specifications into 30,000 candidate attacks, found new HTTP desync techniques and an Apache zero-day, and was never allowed to judge its own results. Here is how it worked, in plain English.
A step-by-step guide to government-signed credentials and zero-knowledge proofs: what the verifier learns, what stays hidden, and how the proof is bound.
Object storage at scale must remember where everything lives. Ceph does not. It computes locations with CRUSH: placement groups, failure domains and weights.
Resource modelling, HTTP methods and status codes, idempotency, RFC 9457 error contracts, and OAuth.
Read one chapter freeWhat an FDE actually does, sourced and cited: Dev vs Delta, and the rounds nobody documents.
Read one chapter freeThe compute, traffic, delivery, and telemetry layers taken apart end to end.
Read one chapter freeThe primitives, then the protocols built on them, worked by hand rather than cited.
Read one chapter freeStorage engines, MVCC, WAL, replication, consensus, and per-engine teardowns.
Read one chapter freeLatency budgets, percentiles, queueing theory, Amdahl and the USL, taught as a discipline.
Read one chapter freeThe building-block decisions an interview is really made of, drilled one visual question at a time.
Read one chapter freeThreat models for LLM apps, the OWASP LLM Top 10, prompt injection, and jailbreaks.
Read one chapter freeThe security mindset and internet foundations through the OWASP Top 10 and API security.
Read one chapter freeQuantization, vectors, matrices, probability, and gradients, for engineers with no ML background.
Read one chapter freeDesign ChatGPT end to end for a billion weekly users and 3.6 billion messages a day. Three models in four pools on B200 GPUs, a context builder that keeps the prefix cache warm, memory, RAG, tools with limits, a stream that survives a dropped phone, safety, post-training with DPO and GRPO, storage, failures and a cost of about $151M a month.
How LLMs work, transformer internals, vector search, inference serving, and distributed training.
Read one chapter freeNew grad to Principal: sample STAR stories and what the interviewer is really scoring.
Read one chapter freeThe loop shape, the weights, and the red flags, company by company and level by level.
Read one chapter freeMental models, core patterns, and the real Go, Java, and Python primitives across nine sections.
Read one chapter freeDesign a maps platform serving 1B daily users with real-time routing, tile rendering, traffic overlays, and offline navigation.
A GitHub-scale code platform modeled end-to-end. Internal components paired with buildable OSS or cloud-managed substitutes. Go monolith on chi + sqlc + Asynq; MySQL behind Vitess; libgit2 via git2go. Start simple; graduate only when pain appears.
A production online auction platform for 10M active listings, 50K bids/sec peak, 1M concurrent WebSocket watchers. Optimistic concurrency via Valkey CAS, Kafka-partitioned bid processing, anti-sniping via atomic extension, effectively-once settlement with fencing tokens, and multi-region active-read / regional-write. Built on Postgres 17, Valkey 8, Kafka 4.0, Flink 1.19.
A production job scheduler for 10M jobs/day with DAG dependencies, fencing-token state commit, target-side idempotency, priority queues with aging, and multi-region failover. Built on PostgreSQL 17, Valkey 8, Kafka 4.0, and Postgres advisory locks (etcd as the upgrade path).
Design an online judge platform like LeetCode handling 50M submissions/day with Firecracker microVM code execution (hardware VM isolation, native snapshot warm-start in ~25ms), multi-language support across 20+ languages, real-time contest leaderboards, Elo rating, and premium priority queue.
Design a production-grade URL shortener for 10B short URLs and 100K redirects/sec with region-prefixed counter IDs, ScyllaDB multi-region replication, multi-layer caching, a real-time click analytics pipeline, and full operational playbook.
Design an ad click aggregation pipeline processing 10 billion clicks/day with Lambda architecture, click fraud detection, exactly-once Flink processing, and sub-minute aggregation freshness for billing.
Design an ad exchange and real-time bidding platform handling 1M ad requests/sec with sub-100ms auction latency, smart DSP selection from 50+ partners, first-price auctions, multi-region deployment, creative serving via CDN, and near-real-time billing reconciliation at $4B/month spend volume.
TCP internals, HTTP/2 and HTTP/3, TLS handshakes, DNS, gRPC, QUIC, and BGP.
Read one chapter freeDesign an e-commerce flash sale platform handling 10M concurrent users with atomic inventory management, a coupon system supporting limited pools and one-per-user enforcement, virtual queue traffic shaping, and payment saga with coupon rollback.
Design a Dropbox-like file sync platform for 500M users with chunked uploads, delta sync, deduplication, and sub-10s cross-device sync.
Design an exabyte-scale object storage system with 11 nines of durability using Reed-Solomon erasure coding, a flat namespace, CDN-accelerated reads, explicit control plane / data plane separation, and an application-layer partial update system built on immutable blobs.
Pick a level and get the real bar for it, plus the path from where you are now.
System design for a complete AI Software Engineer platform: bird's eye architecture, design principles, technology selection, capacity planning, platform data model, and three deep dives from 300ms autocomplete to autonomous app building. Covers context engines, model gateways, agent loops, sandboxes, multi-model routing, long-running memory, crash recovery, multi-agent orchestration, multi-tenant isolation, and an end-to-end walkthrough.
What the kernel actually does with your code, for developers who deploy to Linux every day.
Read one chapter freeDeep dive into designing a production RAG and LLM platform handling 10M queries/day: multi-strategy document chunking, hybrid retrieval with BM25 and dense vectors, cross-encoder re-ranking, tiered model routing, streaming generation, hallucination mitigation with citation grounding, LLM-as-judge evaluation loops, OpenTelemetry observability, multi-tenant isolation, and cost-optimized inference serving.
Design an AI agent platform that automates restaurant operations across thousands of tenants. From anomaly detection to automated dispute resolution, with real-time data pipelines, multi-agent collaboration, and production-grade orchestration.
Design a real-time collaborative editor for 100 concurrent editors per document and 10M active documents using CRDTs and block-based editing.
Deep dive into designing a unified observability platform at 500M metrics/sec: two-tier collection (eBPF + OTel SDK), value-based data routing, VictoriaMetrics storage, Gorilla compression, Kafka ingestion, continuous profiling with Pyroscope, ML anomaly detection, distributed tracing with tail-based sampling, centralized logging, multi-tenant isolation, and SLO-based alerting.
Design a notification platform pushing 100M notifications per second across web, Android, and iOS with at-least-once delivery guarantees.
Probabilistic structures, consensus protocols, and logical clocks, worked for Staff+ engineers.
Read one chapter freeA repeatable six-step framework applied to every LLD problem, starting from requirement mining.
Read one chapter freeDesign a Top-K streaming system processing 7 billion daily events to compute most-watched videos across multiple time windows in real time.
ADRs, RFCs, trade-off analysis, migration strategies, CQRS, and event sourcing.
Read one chapter freeSOC 2, GDPR, HIPAA, PCI DSS, ISO 27001, audit logging, and data residency, for engineers.
Read one chapter freeTechnical vision, build-vs-buy, tech radar, tech debt negotiation, and exec communication.
Read one chapter freeCascading failures, retry storms, thundering herds, rollbacks, and blameless post-mortems.
Read one chapter freeDORA, SPACE, SLO budgeting, and cloud cost work that survives a finance review.
Read one chapter freeTeam topologies, Conway's Law, and scaling an engineering org from 10 to 200 people.
Read one chapter freeInternal developer platforms, golden paths, self-service infrastructure, and Backstage.
Read one chapter freeArchitecture reviews, cross-team leadership scenarios, and ambiguity exercises.
Read one chapter freeTwo pointers, sliding window, BFS, DFS and the rest, in Python, Go, Java, C, and C++.
Read one chapter freeAPI gateways, load balancers, Kubernetes, sharding, CI/CD, and observability.
Read one chapter freeCAP theorem, HTTP status codes, caching strategies, load balancing, and consistency models.
Read one chapter freeDatabases, caching, messaging, time series, geospatial, and stream processing, one article each.
Read one chapter freeEasy to Hard problems with progressive hints, inline cheat sheets, and 40-minute interview plans.
Read one chapter freeCalculators and visualizers you can drive yourself, not screenshots of results.
How x402 uses HTTP 402 to give AI agents a native payment layer, who shipped it in 2026, what the security research found, and why the daily volume is still only $28,000.
Build and deploy Moltbook, an AI-only social network where autonomous agents communicate, share knowledge, and form communities.
The hidden privacy tradeoff in passwordless authentication: how security keys protect against phishing but enable cross-site device tracking.
How end-to-end encryption works in chat apps using X3DH, Double Ratchet, and Sender Keys to protect every message with nine key types.
Design a multi-tenant tagging system for 10K tenants with sub-25ms discovery, global deduplication, and three-tier consistency guarantees.
How BGP connects thousands of autonomous systems to route every DNS lookup, search query, and video stream across the global internet.
How QUIC and WebTransport replace TCP for mobile, 5G, and real-time applications by eliminating head-of-line blocking and reducing latency.
How vector clocks and anti-entropy repair resolve concurrent update conflicts in distributed databases like DynamoDB, Cassandra, and Riak.
A quick overview of ClickHouse, the open-source columnar database built for fast analytical queries using vectorized execution and compression.
A detailed comparison of CockroachDB and Google Spanner, two globally distributed databases that solve consistency and fault tolerance differently.
A deep dive into Domain-Driven Design core concepts, from strategic and tactical design tools to bounded contexts and aggregate modeling.
Learn how Apache Iceberg brings ACID transactions, schema evolution, and time travel to data lakes, and how Trino makes them queryable.
How Apache Pinot achieves 10-50ms query latency on large-scale data with coupled, deep storage, and tiered deployment models.
How Google Spanner uses Paxos consensus and TrueTime to achieve globally consistent transactions across distributed database replicas.
Everything before this predates the log.
New tracks, new deep dives, and new product land here as they go live. Every track opens one chapter to everybody and the deep dives marked free need no account, so you can judge the work before you pay for any of it.