Series
Multi-part deep dives, in order.
Sets of posts that build up a topic from the ground up. Each series has a fixed reading order — start at part 1 and the dependencies fall into place.
- Series 016 parts · ~73 min
JavaScript Engine Internals: how your code actually runs
Six posts trace one function call through execution context, hoisting, closure,
this,new, and garbage collection — the engine's full life cycle.- Execution Context and Call Stack - how JavaScript runs your code
- Hoisting in JavaScript - what the metaphor really means
- Closure in JavaScript, or how a function can remember things
- 3 more parts
Read series →Not started - Series 024 parts · ~66 min
Async JavaScript: how the engine runs your async code
Four posts build the async model bottom-up: event loop, promises as a state machine, async/await, and generators — the pause/resume primitive under it all.
- Event Loop in JavaScript - how the engine decides what runs next
- Promises in JavaScript - from callback hell to the microtask queue
- async/await in JavaScript - how a function can wait without blocking the thread
- 1 more part
Read series →Not started - Series 031 of 4 parts · ~9 min
Performance foundations: Big-O and data structures through frontend code
Big-O and the data structures behind it explained through real frontend code — React re-renders, DOM queries,
Maplookups. No textbook examples.- Big-O without the math: what your code really costs
- Hash maps: why Map and Set lookups are instantComing soon
- Trees and traversals: BFS vs DFS through the DOMComing soon
- 1 more part
Read series →Not started - Series 041 of 3 parts · ~12 min
Web security primer: the same-origin model and what breaks it
How the browser decides who reads whose data: same-origin policy, CORS, then XSS and CSRF - plus the headers and cookie flags that stop them.
- Same-origin policy and CORS: who can read data from another server
- Content Security Policy: directives, nonces, strict-dynamicComing soon
- CSRF and SameSite cookies: tokens, Lax vs Strict vs NoneComing soon
Read series →Not started - Series 053 parts · ~31 min
Caching: from HTTP to the layers you write yourself
Caching layer by layer, one theme throughout: invalidation - what each cache holds and when it lets go. From HTTP headers to the Service Worker cache.
- HTTP caching: why the second visit to a site is instant
- Service Worker - code that answers instead of the server
- Where cache lives: how many copies of one response exist at once
Read series →Not started - Series 061 of 3 parts · ~15 min
Browser rendering: from HTML to pixels and smooth frames
What the browser does between HTML and painted pixels: the rendering pipeline, what blocks a frame (INP), and how the compositor keeps it smooth.
- From HTML to pixel: how the browser renders a page
- INP: what blocks the next paint and how to unblock itComing soon
- Compositor and GPU layers: how scrolling stays smoothComing soon
Read series →Not started
- 07 3 parts
Module systems & bundling: how your code becomes one file
How JavaScript modules load and how a bundler ships dozens of files as one: ESM vs CommonJS, dynamic import, and what tree shaking actually needs to work.
- 08 5 parts
Frontend system design: how user-facing systems actually work
Systems frontend engineers design — notifications, collaborative editing, infinite feeds — look simple until you have to reason about delivery guarantees, conflict resolution and a thousand widgets on one page. Here is what runs underneath each one.
- 09 4 parts
Modern React deep dive: RSC, Server Actions and the client boundary
React 19 changed the model — Server Components run on the server, Client Components hydrate on demand, and Server Actions collapse the client/server split for mutations. This series walks through the pieces one by one: what actually gets sent to the browser, where hydration mismatches come from and how to debug them, when to reach for a Server Action instead of a fetch, and how the new primitives (
use,useOptimistic, transitions) change day-to-day component code. - 10 4 parts
AI for frontend engineers: streaming UI, RAG, and agent loops
How to build applications around LLMs using the frontend stack you already know - from streaming UI with React Server Components, through vector search in serverless functions, to agent loops that call tools and recover from errors without dragging a Python ML stack into your app.