Next.js 16 Cache Components: Where to Put use cache and What It Changes
A look at Next.js 16 Cache Components compares caching a component, caching a data-fetching function, and using no cache. Where you put use cache determines what work is saved and what runs again.
On November 6, 2026, an analysis of Cache Components in Next.js 16 was published. As the author of the article explains, the use cache directive can be placed on a route, a component, or a data-fetching function. Its placement determines what work goes into the cache, but not necessarily whether the component runs on every request. You need to check both how much work is cached and whether the component runs on every request.
What Gets Cached
To test this, the author built a dashboard in Next.js 16.3.2 with three cryptocurrency price cards. They call Binance’s public API and display the price, the 24-hour change, and a chart. The cached areas for Bitcoin and Ethereum use the same cacheLife("demo") profile: stale is 60 seconds, revalidate is 10 seconds, and expire is 300 seconds. Solana caches nothing. This makes it possible to compare what happens with different cache boundaries.
In the Bitcoin card, use cache is placed on the component. The API response, the calculated chart, and the returned JSX are cached together. On a cache hit, the server neither calls the API again nor recalculates the chart. What is stored is a serialized React Server Components result that Next.js can use for subsequent requests.
For Ethereum, the directive is placed on the data-fetching function. The price comes from the cache, but the chart calculation remains outside it. Solana caches neither the API call nor the chart: both operations run again. Bitcoin and Ethereum have the same cache lifetime profile, so the difference between them comes from the cache boundaries, not the cacheLife settings.
Moving use cache from a component to a function does not, by itself, mean the component will run on every request. In this example, Ethereum remains dynamic because the asynchronous chart calculation happens outside the cache. Without that operation, Next.js could include the entire result in the page’s static shell. What gets cached and how often a component runs are separate questions.
What the Measurements Showed—and Their Limits
The author tested the behavior after next build && next start, not in next dev: use cache behaves differently in development. The cards displayed execution counters and data-fetch timestamps. These change when the corresponding code actually runs, helping distinguish a cache hit from another execution.
The time at which each card appeared was measured separately in the browser, when its content reached the user. With a warm cache, Bitcoin appeared after about 40 ms, Ethereum after 445 ms, and Solana after 1084 ms. These are results from this particular demo application, not predictions for every site. In this app, Bitcoin receives a ready-made result, Ethereum also waits for the chart calculation, and Solana waits for an API call as well. Those figures should not be compared with Lighthouse scores without accounting for how they were measured.
cacheLife has thresholds that affect page prerendering. If stale is less than 30 seconds, revalidate is zero, or expire is less than five minutes, the cached area is excluded from the static shell and becomes dynamic. For a component intended to be static, this can cause a next build error: a <Suspense> boundary will be required.
After the revalidate interval passes, the server may immediately serve the previous value while refreshing it in the background. But a request triggers the refresh: without requests, it does not happen. There is also a measurement caveat: the build and the running server operate in separate processes. An in-memory counter can show the same number when a component runs in each process; the data-fetch timestamp helps reveal the difference.
What This Means for Building a Site
Choosing a data lifetime is not enough. Developers need to decide which work can be repeated: fetching data, computing something after the fetch, or rendering the entire component. If an expensive calculation remains outside use cache and runs on every request, a fast response from the cached function will not eliminate the card’s overall delay.
Test the built application and look for two different signals: whether the code ran on the server and when the result appeared to the user. If a page contains several independent sections, the overall response time will not show which one is delayed. It is better to account for cacheLife thresholds and <Suspense> boundaries when choosing the page structure, rather than only after a build error.
My Take
I would start with the user’s main task on a mobile screen, not with deciding where to put the directive. If an important section appears late, first find out what is holding it up: a request, a calculation, or delivery of the result. Then choose a cache boundary that takes the implementation constraints into account. A loading indicator is useful only if it explains the section’s state; it does not remove the delay itself.
Sources
Where the news comes from. The text is a retelling in the author’s own words; the facts come from the source, the opinion is the author’s.
UX design expert
I design interfaces with a particular focus on structure and how quickly people can take them in. I don’t discuss visual choices without a user scenario and implementation constraints.
All posts by the authorRelated articles
Next.js Releases Security Updates for Versions 15.5 and 16.3
Next.js has released versions 16.3.8 and 15.5.27 to fix vulnerabilities involving caching, information disclosure, and image optimization. Teams are advised to update their apps and check which features they use.
Blog Author Drops Next.js and Scores 100 in Every Lighthouse Category
Bloffy’s creator replaced Next.js with Hono for the public-facing blog and scored 100 in every Lighthouse category. Here’s why caching and image optimization weren’t enough.
Cloudflare Introduces Origin Range Requests to Cache Parts of Large Files
Cloudflare has introduced Origin Range Requests to cache parts of large files. Available on all plans, the feature roughly halved R2’s p99 time to first byte after the migration, according to the company.
Discussion 5
Filipa Santos
On a small event site I built, I put `use cache` around the finished agenda component, then found that even a tiny change to the event details meant thinking about the whole cached output. I’m learning to treat the cache boundary like a layout boundary too — basic coding makes those tradeoffs much easier to see.
Eduardo Horta
@filipa.sousa I hit the same thing while practicing with price cards: caching the fetch kept the data work reusable, but I still had to think about what the surrounding component did on each request—those boundaries are easy to mix up at first 😅
Timur Ryskulov
For a store catalog, would you lean toward caching the price fetch and letting the card render per request, rather than caching the finished card? I’m trying to keep updates predictable without making every small product change a bigger cache-invalidation task 😅
Samat Ganiev
That whole-output boundary can make routine agenda edits harder to reason about. For a small center, I’d cache the slower data-fetching function instead, so staff can update event details without invalidating more of the page than necessary.
Elena Pavlu
On a dashboard I worked on, we cached the slow, shared data fetch but left the surrounding component free to render request-specific states, such as the selected date range and loading feedback. That was a better fit than caching the whole card: the price data could be reused without making the UI imply that every part of the card was equally fresh. The useful question is which user scenario needs fresh data on each request, rather than whether the component itself runs again.