React Development for component-driven product interfaces.

Usually re-renders or bundle size rather than computation. Profile before changing anything: look for state held too high in the tree, context values recreated each render, large lists without virtualisation, and libraries imported whole. Memoisation added without a measurement typically adds complexity and no speed.

When genuinely shared across unrelated parts of the tree and not derivable from the server. Server data belongs in a caching layer rather than a global store, since it needs invalidation and staleness handling. Much of what ends up in a global store is either server cache or state that should have stayed local.

A library is usually right for internal tools and early products, where speed matters more than a distinct visual identity. Build your own when the brand expression is part of the product or when accessibility and interaction behaviour need to be exactly specified. Either way, accessibility still needs testing.

Clear component contracts, colocation of related code, a documented approach to state and data fetching, and boundaries that prevent one feature reaching into another's internals. Conventions matter more than any specific library choice, because they are what let a new developer predict where something lives.

For interactive product interfaces, yes — the ecosystem, hiring pool and library support remain the deepest available. The more useful question is which rendering model you need. Content-led sites are often better served by a framework that renders on the server by default than by a client-rendered single-page application.

Test behaviour rather than implementation. Component tests that query by accessible role and label survive refactors and catch accessibility problems at the same time. Add a small number of end-to-end tests over the journeys that would cost real money if they broke, and treat those as the release gate.

Inventory the React version, build tooling, routing and state approach, then move in vertical slices rather than rewriting wholesale. Class components, legacy context and deprecated lifecycle methods can usually coexist with modern code during transition, which keeps the application shippable throughout.

Not inherently, but client-rendered React makes it easy to. LCP suffers when content waits on a JavaScript bundle, and INP suffers when hydration and event handlers block the main thread. Server rendering, code splitting and keeping interactive islands small are what address it.