Build1 distinct publisher3 min readPublished
A dev.to guide pairs route-level caching with a Suspense shell to let Partial Prerendering ship a static shell first. The mechanism is documented; the number behind it is one route.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Do the arithmetic on the headline figure before you touch a route. Removing 700ms of TTFB down to 60-80ms is 620 to 640ms gone, an 89 to 91 percent cut, or somewhere between nine and twelve times faster [12]. That is the cache-hit path, and only the cache-hit path. The directive caches results rather than execution [4], so a miss still runs the expensive fetch in full before the value gets serialised into the RSC payload and folded into the static shell.
Which puts the deploy behaviour at the centre of the estimate. Cache keys include the build id, and a new deploy resets cache entries [7]. Every release therefore buys at least one uncached render per cached route [13], and the first visitor after each deploy gets the ~700ms render the refactor was supposed to delete. The guide's own note that `use cache: remote` is for teams needing a shared durable store across instances with very high hit rates [9] implies the default store is per instance, so that minimum cold count scales with how many instances you run, not how many routes you cached.
The before-and-after metric list is TTFB, FCP and LCP for the shell, and time-to-interactive [10]. Cache hit rate is not on it [14]. Hit rate is the variable that decides whether 60-80ms is your median or your best case, and it is the one number the guide never asks you to record.
The real cost of adoption is not the directive, it is the boundary. You cannot read `cookies()`, `headers()` or `searchParams` inside a `'use cache'` scope; those reads must sit inside a Suspense-wrapped dynamic subtree or the build errors [6]. Any route that currently reaches for request-time context wherever it likes has to be reorganised so that personalised work lives below the boundary and the cacheable work lives above it. That is a data-flow rewrite of the route, and it is why the guide's sequence is fetch once, pass the promise down into the cached boundary, then wrap the slow subtree in a skeleton [1].
Credit where it is due: failing at build time is the right failure mode. A silent stale-personalisation bug is the thing you would fear from a caching directive, and this one refuses to compile instead [6]. The conservative rollout advice matches that: wrap only the heavy server boundary you control and expand later [11], with `cacheLife()` or `cacheTag()` reserved for data that needs a TTL or on-demand invalidation, since the default shell lifespan is deemed adequate for many UI routes [8].
So the mechanism is legible and the guardrails are real. The evidence for the payoff is thinner: one route, described only as a fully dynamic server render replaced by a cached boundary plus a small Suspense shell, with no route size, no traffic profile and no methodology given, plus the observation that the janky transitions frustrating product owners went away [3]. The supplied text stops mid-phrase at "Per-user, highly personalized con" [15], which is exactly where the guidance on unsuitable routes would have been. Treating that single before-and-after as a forecast for your own routes is the part of this recommendation nobody has earned yet.
Ranked by verification strength, evidence, and original report placement.
Cache keys include the build id, so a new deploy will reset cache entries, which the guide says to account for during rollouts.
The dev.to guide recommends, for a route that feels like full SSR with long TTFB and janky client navigations, a conservative route-level 'use cache' plus a small Suspense shell so Partial Prerendering does the heavy lifting; the sequence given is to add 'use cache' at the server component entry for the route, turn heavy fetches into promises consumed inside the boundary, and wrap slow subtrees in Suspense with a tiny skeleton UI.
The surrounding Suspense boundary allows Next.js to return the static shell immediately while streaming the cached or dynamic content into the same HTTP response, which is Partial Prerendering behaviour.
The metrics the guide says to track before and after are TTFB for client navigations and direct loads, FCP and LCP for the critical shell, and time-to-interactive for critical interactions.
The guide advises being conservative at first: wrap only the heavy server boundary you control, and expand later if more saving is needed.
Next.js 'use cache' caches results, not execution: the cached value is serialized into the RSC payload and can become part of the static shell.
Follow any of these and your For You feed starts watching them — no settings page required.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Mechanism specified, headline number unverified
The cluster rests on one community tutorial. Its mechanism-level statements are specific, mutually consistent, and directly quotable (results-not-execution caching, Suspense as the PPR seam, build-id-keyed cache entries, request-time API exclusion, cacheLife/cacheTag roles), which supports a moderate floor. Above that floor there is nothing: no primary documentation, no second publisher, no benchmark artifact, no methodology for the headline TTFB figure, and the captured text is truncated where the guide lists route types the pattern does not suit.
One self-reported route, no deployment data
The only adoption-shaped datapoint is the author's unverified anecdote about a single unnamed route. There is no release note, version pin, deployment disclosure, usage statistic, or second-party report in the supplied sources, so no adoption level can be measured without inventing facts.
One anecdote generalized into an expected outcome
Positive gap: the article promotes a single unverified route result to a general expectation ('in practice this often drops TTFB from ~700ms to ~60-80ms') and lists 'much lower TTFB' among 'key outcomes you can expect', while the cost side is confined to one caveat bullet. The build-id cache reset means the expensive path recurs on every deploy, and the prescribed telemetry omits cache hit rate, so a reader following the guide could not detect that the advertised number applies only to cache hits. The gap is not larger because the article does disclose the reset, the request-time API constraint, and cases where the pattern should not be used.
Engagement-oriented tutorial, no disclosed vendor tie
Observable from the artifact itself: a keyword-shaped '...Guide 2026' community post that closes with an engagement prompt ('What route in your app would you try this on first?') and leans on an unattributable self-reported win, including an appeal to 'product owners' being satisfied. That is the ordinary attention incentive of platform tutorial content. No vendor sponsorship, affiliation, commercial product, or paid placement is disclosed or evidenced, and the article does include caveats against its own recommendation, so the pressure is moderate rather than high.
Single-source cluster, mechanism firmer than numbers
Confidence is limited by structure: one publisher, one article, no corroboration, and a truncated body. What can be said with reasonable assurance is what the guide prescribes and which caveats it names, because those are direct quotations. What cannot be assessed is whether the performance claim generalizes, what the real cache hit rate is, or how large the per-deploy cold-render cost is in practice.
build
Next.js 16 moves the cache decision into the component tree, and the review surface with it1 distinct publisher
build
Five frameworks, one store, and a benchmark that measures when the button works1 distinct publisher
build
Next.js's architecture is working. Its operating manual isn't keeping up.1 distinct publisher
build
Next.js 16.3's memory claim didn't reproduce; its TypeScript handoff cut a build by two thirds1 distinct publisher
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 25, 2026