React 19 introduces several performance improvements under the hood. One big question developers are asking: 👉 Do we still need useMemo and useCallback for memoization?
This article breaks down what’s changed in React 19, how memoization now works out-of-the-box, and whether you should still reach for these hooks in React web and React Native.
🔄 What Changed in React 19?
Traditionally, React re-renders components whenever props or state change. Expensive computations or function recreations could cause performance issues, which is why we’ve used memoization hooks:
- useMemo → cache expensive calculations
- useCallback → memoize stable function references
In React 19, thanks to automatic memoization and compiler optimizations, React can now skip certain re-computations and function recreations more intelligently—without developer intervention.
⚡ How React 19 Reduces the Need for useMemo and useCallback
1. Stable Function References
React 19 automatically keeps function identities more stable in common scenarios. That means fewer unnecessary re-renders when passing callbacks down to child components.
// Before React 19: useCallback was needed
const handleClick = useCallback(() => {
console.log("Clicked!");
}, []);
// React 19: simple function is often enough
const handleClick = () => {
console.log("Clicked!");
};
With the new compiler and reconciler improvements, React is smart enough to avoid re-rendering children if nothing meaningful has changed.
2. Smarter Memoization of Derived Values
React 19 can detect when derived values don’t need recalculating, reducing the need for useMemo.
// Before React 19
const sortedList = useMemo(() => {
return list.sort((a, b) => a - b);
}, [list]);
// In React 19, this may be unnecessary
const sortedList = list.sort((a, b) => a - b);
However, be cautious: if the computation is truly expensive (e.g., heavy data transforms or large list sorting), useMemo still has its place.
🧑‍💻 When You Should STILL Use useMemo and useCallback
Despite React 19’s magic, there are cases where memoization is still developer-controlled:
1. Expensive Calculations
If you’re crunching through big datasets, image processing, or CPU-intensive logic, wrapping in useMemo avoids redundant recalculations.
const heavyComputation = useMemo(() => {
return performComplexMath(data);
}, [data]);
2. Reference Equality in Props
If you’re passing objects/functions into deeply memoized child components (React.memo), you may still need useCallback/useMemo to prevent child re-renders.
const config = useMemo(() => ({ theme: "dark" }), []);
return <ChildComponent config={config} />;
3. 3rd-Party Libraries
Many libraries (like charting libs or form libraries) rely on stable references. Until ecosystem catches up, useCallback helps prevent unnecessary resets.
📱 What About React Native?
React Native apps often deal with:
- Large lists (FlatList, SectionList)
- Gesture handlers (react-native-gesture-handler)
- Performance-sensitive UI updates
While React 19’s improvements benefit React Native as well, mobile apps are more sensitive to unnecessary renders. You’ll likely still need:
- useMemo for optimizing derived lists (e.g., filtering data for a FlatList).
- useCallback for stable event handlers (e.g., swipe gestures, scroll events).
Example
const renderItem = useCallback(({ item }) => {
return <Text>{item.name}</Text>;
}, []);
return <FlatList data={users} renderItem={renderItem} />;
Without useCallback, FlatList might re-create renderItem on every render, hurting scroll performance.
✅ Best Practices in the React 19 Era 1. Start without memoization → Trust React 19’s optimizations. 2. Profile performance → Use React DevTools Profiler to detect bottlenecks. 3. Add useMemo/useCallback selectively → Only for expensive operations or unstable references. 4. Don’t prematurely optimize → Overusing memo hooks can make code harder to read and even hurt performance (extra caching overhead).
🚀 Final Thoughts
- React 19 reduces the need for manual memoization in many scenarios.
- useMemo and useCallback aren’t dead—they’re just special tools for niche cases.
- In React Native, they remain more relevant due to strict mobile performance needs.
The golden rule: Write simple code first, then optimize with memoization only when necessary.
🤝 Need a Custom RSVP System or Dashboard?
I help businesses build tools that actually work — even on tight deadlines.
Whether you're planning an event, need internal tools, or want a custom dashboard for your team — I can help.
Reach out
📧 Email: safi.abdulkader@gmail.com | 💻 LinkedIn: @abdulkader-safi | 📱 Instagram: @abdulkader.safi | 🏢 DSRPT
Drop me a line, I’m always happy to collaborate! 🚀
