React Component Performance
Overview
Identify render hotspots, isolate expensive updates, and apply targeted optimizations without changing UI behavior.
When to Use
- When the user asks to profile or improve a slow React component.
- When you need to reduce re-renders, list lag, or expensive render work in React UI.
Workflow
- Reproduce or describe the slowdown.
- Identify what triggers re-renders (state updates, props churn, effects).
- Isolate fast-changing state from heavy subtrees.
- Stabilize props and handlers; memoize where it pays off.
- Reduce expensive work (computation, DOM size, list length).
- Validate: open React DevTools Profiler → record the interaction → inspect the Flamegraph for components rendering longer than ~16 ms → compare against a pre-optimization baseline recording.
Checklist
- Measure: use React DevTools Profiler or log renders; capture baseline.
- Find churn: identify state updated on a timer, scroll, input, or animation.
- Split: move ticking state into a child; keep heavy lists static.
- Memoize: wrap leaf rows with
memo only when props are stable.
- Stabilize props: use
useCallback/useMemo for handlers and derived values.
- Avoid derived work in render: precompute, or compute inside memoized helpers.
- Control list size: window/virtualize long lists; avoid rendering hidden items.
- Keys: ensure stable keys; avoid index when order can change.
- Effects: verify dependency arrays; avoid effects that re-run on every render.
- Style/layout: watch for expensive layout thrash or large Markdown/diff renders.
Optimization Patterns
Isolate ticking state
Move a timer or animation counter into a child so the parent list never re-renders on each tick.
// ❌ Before – entire parent (and list) re-renders every second
function Dashboard({ items }: { items: Item[] }) {
const [tick, setTick] = useState(0);
useEffect(() => {
const id = setInterval(() => setTick(t => t + 1), 1000);
return () => clearInterval(id);
}, []);
return (
<>
<Clock tick={tick} />
<ExpensiveList items={items} /> {/* re-renders every second */}
</>
);
}
// ✅ After – only <Clock> re-renders; list is untouched
function Clock() {
const [tick, setTick] = useState(0);
useEffect(() => {
const id = setInterval(() => setTick(t => t + 1), 1000);
return () => clearInterval(id);
}, []);
return <span>{tick}s</span>;
}
function Dashboard({ items }: { items: Item[] }) {
return (
<>
<Clock />
<ExpensiveList items={items} />
</>
);
}
Stabilize callbacks with useCallback + memo
// ❌ Before – new handler reference on every render busts Row memo
function List({ items }: { items: Item[] }) {
const handleClick = (id: string) => console.log(id); // new ref each render
return items.map(item => <Row key={item.id} item={item} />);
}
// ✅ After – stable handler; Row only re-renders when its own item changes
const Row = memo(({ item, onClick }: RowProps) => (
<li => onClick(item.id)}>{item.name}</li>
));
function List({ items }: { items: Item[] }) {
const handleClick = useCallback((id: string) => console.log(id), []);
return items.map(item => <Row key={item.id} item={item} />);
}
Prefer derived data outside render
// ❌ Before – recomputes on every render
function Summary({ orders }: { orders: Order[] }) {
const total = orders.reduce((sum, o) => sum + o.amount, 0); // runs every render
return <p>Total: {total}</p>;
}
// ✅ After – recomputes only when orders changes
function Summary({ orders }: { orders: Order[] }) {
const total = useMemo(() => orders.reduce((sum, o) => sum + o.amount, 0), [orders]);
return <p>Total: {total}</p>;
}
Additional patterns
- Split rows: extract list rows into memoized components with narrow props.
- Defer heavy rendering: lazy-render or collapse expensive content until expanded.
Profiling Validation Steps
- Open React DevTools → Profiler tab.
- Click Record, perform the slow interaction, then Stop.
- Switch to Flamegraph view; any bar labeled with a component and time > ~16 ms is a candidate.
- Use Ranked chart to sort by self render time and target the top offenders.
- Apply one optimization at a time, re-record, and compare render counts and durations against the baseline.
Example Reference
Load references/examples.md when the user wants a concrete refactor example.
Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
1---2name: react-component-performance3description: Diagnose slow React components and suggest targeted performance fixes.4risk: safe5source: "Dimillian/Skills (MIT)"6date_added: "2026-03-25"7metadata:8 source: https://skillmd.com/skills/mhassan0000/react-component-performance9---1011# React Component Performance1213## Overview1415Identify render hotspots, isolate expensive updates, and apply targeted optimizations without changing UI behavior.1617## When to Use18- When the user asks to profile or improve a slow React component.19- When you need to reduce re-renders, list lag, or expensive render work in React UI.2021## Workflow22231. Reproduce or describe the slowdown.242. Identify what triggers re-renders (state updates, props churn, effects).253. Isolate fast-changing state from heavy subtrees.264. Stabilize props and handlers; memoize where it pays off.275. Reduce expensive work (computation, DOM size, list length).286. **Validate**: open React DevTools Profiler → record the interaction → inspect the Flamegraph for components rendering longer than ~16 ms → compare against a pre-optimization baseline recording.2930## Checklist3132- Measure: use React DevTools Profiler or log renders; capture baseline.33- Find churn: identify state updated on a timer, scroll, input, or animation.34- Split: move ticking state into a child; keep heavy lists static.35- Memoize: wrap leaf rows with `memo` only when props are stable.36- Stabilize props: use `useCallback`/`useMemo` for handlers and derived values.37- Avoid derived work in render: precompute, or compute inside memoized helpers.38- Control list size: window/virtualize long lists; avoid rendering hidden items.39- Keys: ensure stable keys; avoid index when order can change.40- Effects: verify dependency arrays; avoid effects that re-run on every render.41- Style/layout: watch for expensive layout thrash or large Markdown/diff renders.4243## Optimization Patterns4445### Isolate ticking state4647Move a timer or animation counter into a child so the parent list never re-renders on each tick.4849```tsx50// ❌ Before – entire parent (and list) re-renders every second51function Dashboard({ items }: { items: Item[] }) {52 const [tick, setTick] = useState(0);53 useEffect(() => {54 const id = setInterval(() => setTick(t => t + 1), 1000);55 return () => clearInterval(id);56 }, []);57 return (58 <>59 <Clock tick={tick} />60 <ExpensiveList items={items} /> {/* re-renders every second */}61 </>62 );63}6465// ✅ After – only <Clock> re-renders; list is untouched66function Clock() {67 const [tick, setTick] = useState(0);68 useEffect(() => {69 const id = setInterval(() => setTick(t => t + 1), 1000);70 return () => clearInterval(id);71 }, []);72 return <span>{tick}s</span>;73}7475function Dashboard({ items }: { items: Item[] }) {76 return (77 <>78 <Clock />79 <ExpensiveList items={items} />80 </>81 );82}83```8485### Stabilize callbacks with `useCallback` + `memo`8687```tsx88// ❌ Before – new handler reference on every render busts Row memo89function List({ items }: { items: Item[] }) {90 const handleClick = (id: string) => console.log(id); // new ref each render91 return items.map(item => <Row key={item.id} item={item} onClick={handleClick} />);92}9394// ✅ After – stable handler; Row only re-renders when its own item changes95const Row = memo(({ item, onClick }: RowProps) => (96 <li onClick={() => onClick(item.id)}>{item.name}</li>97));9899function List({ items }: { items: Item[] }) {100 const handleClick = useCallback((id: string) => console.log(id), []);101 return items.map(item => <Row key={item.id} item={item} onClick={handleClick} />);102}103```104105### Prefer derived data outside render106107```tsx108// ❌ Before – recomputes on every render109function Summary({ orders }: { orders: Order[] }) {110 const total = orders.reduce((sum, o) => sum + o.amount, 0); // runs every render111 return <p>Total: {total}</p>;112}113114// ✅ After – recomputes only when orders changes115function Summary({ orders }: { orders: Order[] }) {116 const total = useMemo(() => orders.reduce((sum, o) => sum + o.amount, 0), [orders]);117 return <p>Total: {total}</p>;118}119```120121### Additional patterns122123- **Split rows**: extract list rows into memoized components with narrow props.124- **Defer heavy rendering**: lazy-render or collapse expensive content until expanded.125126## Profiling Validation Steps1271281. Open **React DevTools → Profiler** tab.1292. Click **Record**, perform the slow interaction, then **Stop**.1303. Switch to **Flamegraph** view; any bar labeled with a component and time > ~16 ms is a candidate.1314. Use **Ranked chart** to sort by self render time and target the top offenders.1325. Apply one optimization at a time, re-record, and compare render counts and durations against the baseline.133134## Example Reference135136Load `references/examples.md` when the user wants a concrete refactor example.137138## Limitations139- Use this skill only when the task clearly matches the scope described above.140- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.141- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.