Common Pitfalls: Deferring Primitives
What you'll learn: Why useDeferredValue works best with derived state objects, not simple primitive values directly from input.
The Core Problem
Here's a common mistake: wrapping a simple string or number directly with useDeferredValue and expecting magic performance gains. The hook itself doesn't make rendering faster—it only helps when the deferred value triggers expensive derived computations or renders heavy component trees.
If you defer a primitive that doesn't drive complex work, you're just adding unnecessary overhead without any benefit.
Why Primitives Alone Don't Benefit
// ❌ Pointless deferral
const [searchText, setSearchText] = useState('');
const deferredText = useDeferredValue(searchText);
return <input value={searchText} onChange={e => setSearchText(e.target.value)} />;
// The deferredText isn't even used!
The deferred value only matters when it drives expensive work:
// ✅ Useful deferral
const [searchText, setSearchText] = useState('');
const deferredText = useDeferredValue(searchText);
// The deferred value filters a massive list
const filteredItems = useMemo(() =>
expensiveFilter(items, deferredText), [items, deferredText]
);
return (
<>
<input value={searchText} onChange={e => setSearchText(e.target.value)} />
<HeavyList items={filteredItems} />
</>
);
The Real Pattern
useDeferredValue shines when the deferred value is used to compute derived state that's expensive to recalculate. Think filtered arrays, sorted data, or rendering thousands of DOM nodes. The primitive itself isn't what matters—it's what you do with it that counts.
Key Takeaway: Don't defer primitives just because you can—defer them only when they drive expensive derived computations or render heavy component trees. Otherwise, you're adding complexity for zero gain.