Product metrics answer a different question from "is the frontend fast?" — they ask whether the product delivers value: do people show up, do they reach the aha moment, do they come back, and do they stick around. Almost all of it is measured in the browser by frontend event tracking, but the numbers describe the product, not the frontend's health. Here's the set that actually changes decisions.
A Claude Code Starter Setup for a Vite + React + TypeScript Project (CLAUDE.md, Hooks, and Skills)
Most people install Claude Code, talk to it like a chatbot, and stop there. The difference between that and a genuine force multiplier is a small amount of configuration: a file that tells it your conventions, a couple of hooks that enforce quality automatically, and one skill that encodes a workflow you'd otherwise re-type every day.
Every Type of Software Test, and Whether It's Worth It
There are more kinds of software test than anyone can keep straight — unit, integration, contract, snapshot, mutation, smoke, load, chaos. This post walks through each one, what it actually buys you, and whether it earns its place in a real codebase.
How a running Next.js app talks to the server: RSC fetches and Server Actions
When you first open a Next.js app, the browser downloads a document: a page of HTML (HyperText Markup Language). The browser reads it, and then React makes it interactive (this step is called hydration). After that, open the Network tab of your browser's developer tools and you'll see that the app never asks for a document again. Instead you see a small, steady number of unusual requests. Some are GETs that return something that isn't HTML. Others are POSTs to the page you're already on, and their answer arrives in pieces. Those POSTs look the strangest, and they're what this post explains.
From URL bar to interactive: what really happens when a Next.js app boots
You type a domain, hit Enter, and a second later you're clicking around a working app. That second is deceptively busy. Between the keystroke and the first working button there's a DNS lookup, a couple of cryptographic handshakes, a streamed HTML document, a fan of parallel downloads, a serialized React tree, and a reconciliation pass that stitches JavaScript onto server-rendered markup without throwing any of it away.
Design Systems: From Web to Mobile
A design system that starts on the web rarely fits mobile directly. This post shows what still works on mobile, what doesn't, and how to keep one source of truth (one place that stores each design decision) for both.
Every Way to Render a React Component, From 2013 to Now
"Rendering" is one of those words that means three different things depending on who you ask. Before we walk the timeline, it helps to separate the layers:
- The rendering API — the actual function you call (
ReactDOM.render,createRoot,renderToString…) to turn a component tree into DOM or HTML. - The rendering strategy — where and when the HTML is produced: in the browser, on a server per-request, at build time, etc.
- The hydration model — how a server-produced HTML page becomes interactive on the client. The post is organized around layer 2 (strategies), because that's where the chronological and simple-to-complex story is richest — but each strategy is tagged with all three: an At a glance box names its rendering API and hydration model too. There's also a short section near the end that lists the API methods on their own, since "render a component" can literally mean those. Each strategy also has a Metrics table in web-vitals shorthand (TTFB, FCP, LCP, TBT, INP, CLS) — every acronym in this post is spelled out in the Glossary at the end.
One honest caveat up front: chronology and complexity mostly line up, but not perfectly. Islands and streaming SSR landed around the same time, for example. I've ordered primarily by conceptual complexity and noted the rough dates as we go.
HTTP: The Hidden Essentials Every Developer Should Know
Every framework, HTTP client, and browser hides the protocol behind a few convenient calls — so most developers never see the request that actually goes over the wire. This post pulls back that curtain: the communication model, the methods, the status codes, and the headers you've been using all along without knowing it.
Frontend Debugging Cookbook — React SPA vs. Next.js
Debugging a React single-page application (SPA) and debugging a Next.js App Router app are different sports, and the whole difference comes down to one thing: where your code runs. This is a recipe-oriented reference for the questions that keep coming up — where your logs went, how to see backend calls, how to observe React Server Components (RSC), and which logging options and tools are worth reaching for.
How JavaScript Bundlers Work: A Field Guide from 2012 to 2026
Bundlers are the most invisible critical infrastructure in frontend development. Every npm run dev and every continuous-integration (CI) pipeline runs through one, yet most of us only think about them when something breaks or when a migration guide lands in our feed. This post is an attempt to fix that: what a bundler actually does under the hood, how we got from script tags to Rust toolchains, which tool owns which niche today, and where the whole thing is heading.
