A shared UI kit does not fail because the button component is hard to write. It fails when five applications are afraid to upgrade it. Versioning, contract tests, release channels, and migration paths are what turn a component library from a dependency into a product people can trust.
Writing the new version of a shared component is the easy 10%. The other 90% is the hundred call sites that already depend on the old one — and the fear of touching them. Here's how I change a component everyone uses without a month-long rewrite that breaks the day it lands.
The most reusable UI code I write renders nothing at all. Headless components, render props, and hooks-as-API are three names for one idea: separate what a component does from how it looks — and hand over the behavior without a single opinion about the markup.
The moment a component grows past a handful of props, you're not writing a component anymore — you're designing an API. Compound components are how you keep that API flexible without drowning it in configuration props.
The pattern that taught a generation to split 'smart' from 'dumb' components got quietly declared obsolete when hooks arrived. It wasn't. The folder convention died. The idea underneath it is more useful now than ever — including in Server Components.
Split a component too early and you get a maze of tiny files. Split too late and you get a 600-line monster. The real question isn't size — it's who owns which dependency, and whether the component reaches for it or is handed it.
You can draw whatever folder diagram you like. The honest picture of your app is which module imports which — the direction of the arrows. Get that wrong and no folder structure will save you.
A barrel file makes imports look beautiful and can quietly drag half your app into a bundle that only needed one function. Here's what index.ts actually does, when it earns its place, and when it's a trap wearing a clean interface.
Every codebase grows a shared/ folder, and given enough time every shared/ folder becomes a junk drawer. Not because the team got lazy — because the folder was never given a rule. Here's why it rots, and how to keep it boring.
The idea that React could render a 3D scene sounds like a stretch — React is for interfaces, 3D is a different universe. Except it isn't a stretch at all, and understanding why closes out this whole series with its central idea: React was never really about the DOM. This is where that finally becomes obvious.
React Native's promise gets misremembered as 'write once, run everywhere' — and that misremembering is why so many web developers hit a wall. The knowledge transfers; the code and the instincts often don't. Here's the honest line between what your React experience buys you on mobile and what it quietly doesn't.
The pitch is irresistible — ship your React app as a real desktop program, same code, native icon in the dock. Electron and Tauri both promise it. But the interesting question isn't 'can I,' it's 'what do I actually gain that a browser tab can't give me,' and the answer decides which tool, and whether you should bother at all.
Every team writes component docs the same way — a wiki page, a screenshot, a table of props — and every team watches them go stale within a month. The problem isn't discipline. It's that the docs live in a different place than the code. The fix is docs that can't drift because they're generated from the component itself.
Most engineers treat the Figma file as a picture to reproduce. That framing is why so many handoffs go badly. A good design isn't a picture — it's the first draft of your component architecture, and the decisions that decide whether your codebase stays sane are made before a single line of React is written.
"Just send them an email" is one of those sentences that sounds like a five-minute task and turns into a week. The React part is trivial. The hard part is that email is a deceptively deep backend system with deliverability, templates, and reputation — and none of it belongs in your frontend. Here's where the real work actually is.
An upload looks like a one-liner — a file input, a POST, done. Then someone uploads a two-gigabyte video on hotel wifi and the whole illusion collapses. The hard part was never the input. It's moving a large, unreliable blob of bytes from a browser to somewhere it can live. Here's how I actually handle it.
Dates look like the most boring data type in your app. They are also the source of the subtlest, most embarrassing bugs — the meeting that shows an hour off, the 'today' that's tomorrow in Tokyo, the date that shifts a day every time you save it. Here's how I stop time from quietly breaking a React app.
Taking a payment looks like a form submission and is nothing like one. The card number is radioactive, the confirmation is asynchronous, and the one thing your React app must never do is believe it got paid because a callback said so. Here's where the real line sits between the browser, your server, and Stripe.
Everyone thinks i18n means swapping English strings for a dictionary lookup. That's the 10% that's easy. The 90% is formatting, pluralization, text that changes direction, and language data you can't afford to ship all at once. Here's what internationalizing a React app actually involves once you get past the word 'translation'.
FSD is one of the best frontend methodologies out there. Used without thinking, it turns a complex component into a scavenger hunt across eight folders. Here's what I learned.
Every data pattern so far has the client asking and the server answering. Real-time inverts that — the server speaks first, and your UI has to be listening. The mistake is treating that live connection as a second, parallel source of truth. Here's how I keep a React app live without ending up with two states that disagree.
The demos are intoxicating — a chat box, a streaming response, thirty lines of code and it feels like magic. Then you try to ship it and the hard parts show up all at once: streaming UI, structured output you can trust, state that doesn't fight you. Here's what building AI into a real React app actually takes.
Most testing advice is either "100% coverage" zealotry or "tests slow you down" cynicism. Both miss the point. A test is a trade — effort now for confidence later — and the skill is knowing which trades pay off. Here's how I test React without a brittle suite that everyone hates.
Deployment used to be a separate discipline — servers, pipelines, a person whose whole job was getting code to production. Modern platforms compressed it into a git push. Here's how to think about hosting a React app, what the tiers actually mean, and where the magic stops.
"Add a database" used to mean provisioning a server, managing connections, and running migrations by hand. Serverless quietly rewrote that whole sentence. Here's what a React developer actually needs to know about picking and using a database in 2026.
Server rendering isn't a performance checkbox — it collapses the wall between frontend and backend into one framework. Here's what SSR really buys you, why the client/server line stops being where you think it is, and where TanStack Start fits next to Next.js.
You don't have to write the server. But the shape of the contract between your React app and the backend — REST, tRPC, or a BFF — decides how much of your frontend is real work versus glue code. Here's the part of the backend that's actually yours.
Auth looks like a login form and turns out to be an architecture decision. Where do tokens live, who guards a route, what happens when the session dies mid-request? Here's why I buy auth instead of building it, and the parts that stay yours no matter what you buy.
"Just use a chart library" hides a real decision. Do you want charts handed to you, or do you want to control every pixel? That choice — and your data size — decides between Recharts, visx, and raw D3. Here's how I pick, and where charts actually get hard.
Forms are where clean React apps quietly fall apart. Conditional fields, async validation, a submit button that has to know about everything — it adds up fast. Here's why I reach for TanStack Form, where it beats Formik and React Hook Form, and where a form library still can't save you.
Picking a component library feels like picking buttons and modals. It isn't. You're deciding who controls your styling — you or the library — and that single choice shapes how much you'll fight it for years. Here's how I weigh MUI, Ant Design, Radix, and shadcn/ui.
Styling is the most argued-about, least reasoned-about decision in a React app. The real question isn't which library looks nicest in a demo — it's which one survives a growing codebase. Here's how I weigh Tailwind, CSS Modules, CSS-in-JS, and zero-runtime options, and where each one earns its place.
A module I was told not to over-engineer grew into an entire application. Most of what let it survive was boring — and one of the most boring rules was never mutating state in place. Here's how immutability actually works in React, when I reach for Immer, and why I skip Immutable.js.
Most React state doesn't need a library. Then one workflow grows into drafts, derived values, undo, optimistic steps, and cross-component coordination. This is where I reach for Reatom instead of turning TanStack Query into a client-state store.
Routing is not just rendering a page for a path. In serious React apps, the URL carries product state: filters, tabs, pagination, selected records, redirects, and preload decisions. TanStack Router makes that state typed instead of hopeful.
TanStack Query is not just a better useEffect. It is the server-state layer of your React app. The hard part is not fetching data — it is designing keys, freshness, invalidation, pagination, and prefetching so the UI stays predictable.
Error handling is not a catch block sprinkled at the end. In a React + TanStack app, it is a product decision: what fails locally, what fails at the route level, what can retry, and what the user needs to do next.
Flat folders are fine until every feature starts touching routes, queries, forms, permissions, and UI state. Here's the React structure I use when a TanStack app grows past the simple stage without turning FSD into folder theater.
Not a TypeScript tutorial. A focused look at the patterns that eliminate real production bugs in React + TanStack apps — typed API layers, discriminated unions for async state, route param inference, and generic components done right.
Every new React project starts with the same question: which tools? After years of watching teams assemble mismatched libraries that fight each other, I stopped choosing independently. This is the coherent stack I now use by default — and why.
How to build component libraries that teams actually want to use.
Leveraging TypeScript for better developer experience and fewer runtime errors.
Practical techniques for building fast React applications at scale.