Hands-on explanations with live demos. Every post has something to drag, type into or break.
Synchronous calls vs asynchronous messages, what each API style is good at and what it costs, receiving webhooks safely, and the rules of message queues. With demos using real bytes.
How the server sends you something when HTTP only lets you ask: polling, long polling, Server-Sent Events, WebSockets, WebRTC and WebTransport, and what breaks in production.
What HTTPS protects and what it doesn't, how two strangers agree on a secret in public, the TLS 1.3 handshake step by step, and what the browser checks in a certificate. With demos.
Part 2 of How browsers work: rendering engines, sandboxed processes and site isolation, the main thread vs the compositor, how a frame is made, and why pages jank. With a demo that really blocks your main thread.
MPA, SPA, SSR, SSG, ISR, streaming, partial prerendering, islands, Server Components and resumability: how each works, what it's good at, what it costs, and how to choose.
When and where each rendering mode fetches data and builds HTML, partial prerendering with Cache Components in Next.js 16, and who sees stale data with ISR. With timeline demos.
The order a query really runs in, how the planner picks a plan from statistics, when it ignores your index, join algorithms, EXPLAIN, and what happens on a write.
The stages of scaling a web app, from one server to sharded databases, and the failure modes that cause real outages: retry storms, missing timeouts, tail latency and overload.
How V8 parses lazily, runs bytecode in Ignition, tiers up through Sparkplug, Maglev and TurboFan, and uses hidden classes and inline caches to make dynamic objects fast.
How the browser picks one value per property, why specificity is compared column by column, why flex items won't shrink, and why z-index: 9999 doesn't work.
V8 and libuv, what the 4-thread pool does (and doesn't) handle, the phases of Node's event loop, and why one blocking request slows down every user. With a demo where you block a server yourself.
What the compiler checks, how it infers and narrows types line by line, and why every type is gone at runtime. With a narrowing demo and a live playground.
DNS, TCP, TLS and HTTP, then parsing, the DOM and CSSOM, layout, paint and compositing. Follow one request end to end, with demos of where the time goes.
What happens when a line of JavaScript runs: parsing and JIT compilation, the call stack and heap, hoisting, closures and the event loop, with a step-by-step demo.
What JSX compiles to, what rendering really means, how React diffs trees and uses keys, and why state is a snapshot. With live demos and a 30-line React you can edit.
Core Web Vitals, wasted re-renders, debouncing and bundle size, each with a live demo you can poke at to see what actually makes a page feel fast.
Load balancers, caches, databases and the trade-offs between them. Scale a toy app from one server to many and watch where it breaks.