🔬 How It Actually Works

Deep dives into the tools you use every day

Every Saturday
  1. #21

    How WebSockets Actually Work Under the Hood

    WebSockets upgrade an HTTP connection to a persistent, bidirectional channel. Here's the upgrade handshake, framing protocol, and when to use them.
  2. #20

    How Load Balancers Actually Work — Algorithms, Health Checks, and Sticky Sessions

    Load balancers distribute traffic across servers. Here's how they decide where to send each request — round robin, least connections, and more.
  3. #19

    How Database Indexes Actually Work — B-Trees, Hash Indexes, and When to Use Them

    Indexes make queries fast. But how? B-tree structure, index scans vs sequential scans, composite indexes, and when indexes hurt performance.
  4. #18

    How Git Actually Works — Objects, Trees, Commits, and Refs

    Git isn't magic. It's a content-addressable filesystem. Here's how objects, trees, commits, and refs work under the hood.
  5. #17

    How Docker Containers Actually Work — Namespaces, Cgroups, and Layers

    Containers aren't lightweight VMs. They're isolated processes using Linux kernel features. Here's what Docker actually does under the hood.
  6. #16

    How OAuth Actually Works — Tokens, Flows, and Why It's Confusing

    OAuth lets users log in with Google/GitHub without sharing passwords. Here's how authorization codes, access tokens, and refresh tokens actually work.
  7. #15

    How HTTPS and TLS Actually Work — The Handshake Explained

    Every HTTPS request starts with a TLS handshake. Here's what actually happens — certificates, keys, cipher suites, and why it's fast now.
  8. #14

    How DNS Actually Works — A Developer's Guide

    You type a URL, a website loads. But what happens in between? DNS resolution, caching layers, TTL, record types, and why your deploy takes 48 hours to propagate.
  9. #14

    How Rate Limiting Actually Works (Token Bucket, Sliding Window, and More)

    Rate limiting isn't just 'X requests per minute.' Here's how token bucket, sliding window, and leaky bucket algorithms work, with real implementations.
  10. #13

    How Prompt Caching Works — And Why It Saves You 90% on AI API Costs

    Prompt caching lets you reuse processed context across API calls. How it works, which providers support it, and how to implement it.
  11. #13

    How Environment Variables Actually Work (From Shell to Container)

    Environment variables aren't magic. They're inherited from parent processes, read from .env files by your framework, and isolated by containers. Here's the full chain.
  12. #12

    How Transformers Actually Work — A Visual Guide for Developers

    The transformer architecture powers every modern AI model. Here's how attention, embeddings, and feed-forward layers work — explained without a PhD.
  13. #12

    How Git Merge vs Rebase Actually Works (With Visual Examples)

    Merge creates a commit. Rebase rewrites history. Here's what actually happens to your commits with each approach, when to use which, and why teams fight about it.
  14. #11

    How Embeddings Work — The Math Behind Semantic Search, Explained Simply

    Embeddings turn text into numbers that capture meaning. Here's how they work, why 'king - man + woman = queen', and how to use them in your apps.
  15. #11

    How Docker Networking Actually Works Under the Hood

    Bridge, host, overlay, none — Docker networking modes explained with diagrams and real examples. Why your containers can't talk to each other, and how to fix it.
  16. #11

    How SSH Actually Works Behind the Scenes

    You type ssh user@server and you're in. Here's what actually happens: key exchange, authentication, channels, and why it's so secure.
  17. #10

    How Tokenizers Work — Why 'strawberry' Has 3 Tokens

    Tokenizers split text into pieces AI models understand. BPE, SentencePiece, tiktoken — how they work, why they matter, and why token counts surprise you.
  18. #10

    How DNS Resolves a Domain Name (The Full Journey)

    When you type a URL, your browser doesn't know where to go. DNS translates the domain to an IP address. Here's every step of that journey.
  19. #9

    How Hot Reload Actually Works Under the Hood

    You save a file and the browser updates instantly. Here's what actually happens: file watchers, module graphs, HMR protocols, and why it sometimes breaks.
  20. #8

    How JWT Actually Works (And Why It's Not Encryption)

    JWTs are everywhere in modern auth. Here's what's actually inside them, how signing works, and the security mistakes most developers make.
  21. #7

    How WebSockets Actually Work Behind the Scenes

    WebSockets aren't magic. Here's exactly what happens during the handshake, how frames are structured, and why they're different from HTTP.
  22. #6

    How CORS Actually Works (And Why Your Request Gets Blocked)

    CORS errors are the most frustrating part of web development. Here's exactly what the browser does, why preflight requests exist, and how to fix it properly.
  23. #5

    How React's Virtual DOM Actually Works

    React doesn't update the real DOM directly. It diffs a virtual copy first. Here's the reconciliation algorithm explained simply.
  24. #4

    How HTTPS Actually Keeps Your Data Safe

    HTTPS isn't magic. It's a handshake, a key exchange, and symmetric encryption. Here's the full process in plain English.
  25. #2

    How Git Tracks Your Changes (It's Not What You Think)

    Git doesn't store diffs. It stores snapshots. Here's how Git actually works under the hood — blobs, trees, commits, and refs.
  26. #1

    How npm install Actually Works Behind the Scenes

    Ever wondered what happens when you run npm install? Here's the full process: resolution, fetching, linking, and why it sometimes breaks.