Contents (5)
[Blog] Record of the Transition from ISR to PPR
With PPR and Cacheable Component features being incorporated as official Next.js features, there have been significant changes to caching strategies.
The existing SSR Streaming method required the entire screen to be redrawn at all times, but with PPR becoming an official feature, static parts can be pre-rendered and only the remaining dynamic parts can be newly drawn and filled in.
In other words, compared to the existing SSR Streaming method that forces a choice between Static and Dynamic pages, it has become possible to use the PPR method, which allows mixing static, cached, and dynamic content within a single route.
In this post, I would like to share the difficulties I experienced while switching from the ISR caching method (posts, categories SSG) to the PPR caching method, and the trade-offs I think are important .
Trade-offs with the transition of caching and rendering strategies from ISR to PPR
Nextjs 15 | Nextjs 16 |
|---|---|
Next.js App Router Page ISR Caching Code Post API of the domain package | Settings for using PPR in Next.js Post component PPR code in Next.js |
If you look at the code above, you can see that the way caching is applied has completely changed.
When using ISR, cache the page using a route segment config called revalidate, and cache API results for the desired amount of time using the revalidate option in the fetch function wrapped in Next.js.
When using PPR, you can cache at the file or component (function) level using the "use cache" directive, and specify the caching time and tag using cacheLife and cacheTag. Additionally, existing route segment configurations can no longer be used. Of course, the revalidate option of the fetch function is still available.
And let's compare the two methods in terms of intuitiveness, usability, and separation of dependencies.
In terms of intuitiveness, it is difficult to immediately understand what the value 'revalidate' is for in the ISR approach. However, in the PPR approach, the intention of exactly what is to be done is revealed by the directive "use cache".
In terms of usability, the ISR method is either entirely static or, even if partial streaming is used, inevitably requires rendering the page entirely dynamically. However, with the PPR method, the layout is statically pre-rendered, allowing only the content to be rendered dynamically, and it can even be cached and streamed.
In terms of dependency separation , traditional caching methods always encroached upon the API layer to cache API results . Next.js's implementation of caching by adding the `revalidate` property to the `fetch` function created a strong coupling between caching and the API layer. However , with the `use cache` approach, since function results can be cached, it has become possible to cache without encroaching on the API layer . (It feels incredibly liberating to be able to separate the coupling from the API layer! Because of this, I no longer need to perform type declarations in the API layer that I separated into a package from the monorepo.)
division | ISR (Incremental Static Regeneration) | PPR (Partial Prerendering) |
|---|---|---|
Basic concepts | Static generation of the entire page + periodic regeneration | Separate the page into static and dynamic fragments |
Pre-render range | Page units | Subtree unit within a Route |
Dynamic content processing | Full page regeneration required | Runtime rendering only the dynamic parts |
Caching criteria | revalidate (time-based) | Based on "use cache", cacheLife, cacheTag |
HTML generation time | When building + when re-verifying | At build (static) + on request (dynamic) |
User response | Always complete HTML | Static HTML Immediate + Dynamic Streaming |
TTFB | Very fast | Fast (static shell delivered immediately) |
TTI | Proportional to page size | Delay only the dynamic parts |
Re-verification costs | Full page | Only the necessary subtrees |
Performance measurement and changes in the transition from ISR to PPR
I measured how performance changed when switching from ISR to PPR. (However, it is unfortunate that the measurement was affected because I accidentally included the font download method.)
Device performance measurement method
My device performance
Target device performance
Lighthouse Benchmark score 4246
Targeting Low-End Desktops
Since the Lighthouse CPU benchmark score is 4246, I applied CPU Throttling 4X to adjust the score to between 1000 and 1500 points for measurement.
Network speed was measured by targeting [4GFast] , taking into account the poor network environment, even though it is a desktop environment.[4GFast]
label="4G Fast (10 Mbps, 40ms RTT)"
bwIn=10240000
bwOut=10240000
latency=40
The final performance measurement instruction applied was [CPU Throttling 4X, latency 40, 10Mbps].lighthouse --throttling-method=devtools
--preset=desktop
--throttling-method=devtools
--throttling.requestLatencyMs=40
--throttling.downloadThroughputKbps=10000
--throttling.uploadThroughputKbps=10000
--throttling.cpuSlowdownMultiplier=4
https://yooncarrot.com/category/Introduction/BlogIn addition, it was measured using a performance tool with [CPU Throttling 4.0X, Fast 4G].
CPU : | ISR Caching Strategy | PPR Cashing Strategy |
|---|---|---|
RSC Payload Size | ![]() | ![]() |
FCP (First Contentful Paint) INP (Interaction to Next Paint) CLS (Cumulative Layout Shift) | ![]() ![]() ![]() | ![]() ![]() |
| ||
Overall, the key points are improvements in RSC Payload size, INP, and FCP metrics. Since only a static portion is pre-rendered, INP and FCP have improved significantly. Additionally, because only the streaming portion is retrieved, the size of the RSC Payload has been drastically reduced, leading to improvements in server resource consumption, network costs, and user experience.
Traditional caching/rendering strategies
Traditionally (prior to Next.js 16), various concepts exist in Next.js, such as Server Component, Client Component, dynamic, SSG, ISR, SSR, CSR, and PPR. Let's classify them.
HTML rendering time (caching status + time)
SSG -> Build time
ISR -> Build time + Revalidate time
SSR -> Request time
CSR -> When needed by the client
Code execution environment
Server Component (Server)
Client Component (Server + Client)
dynamic + ssr:false (client)
HTML rendering timing strategy combination
PPR (SSG + SSR + ISR)
Now that you have a clear understanding of the classifications above, it would be a good idea to examine which concepts should be used in which situations. I have categorized them in my own way, but please keep in mind that this is not always the correct answer, as there are so many different situations in reality.
caching
When SSG is suitable
Completely static pages (landing pages, documentation pages, etc. that can be generated during the build)
When ISR is suitable
Dynamic or infrequently changing pages (blog posts, news articles, product details)
When SSR is suitable (no caching)
Pages where data at the time of request is important (search results pages, user profiles)
When CSR is suitable (no caching)
Pages using browser-specific APIs such as Canvas, WebGL, etc. (editors, charts, etc.)
When SEO importance is low
When PPR is suitable
Pages that need to render both dynamic and static parts together (home screen with personal widgets)
Code execution environment
Server Component
Components without user interaction
Client Component
components with user interaction
dynamic + ssr:false
Components that use APIs that cannot be executed in a server environment
Has that helped clarify things? In addition to this, you should now know that you can also cache at the component and function level by utilizing "use cache."
conclusion
As Next.js is updated, many good features are being released, along with many that are still in the experimental stage. I think it is good that this allows for much more systematic management. However, I believe the increased complexity is leading to an overload. If you visit the GitHub Next.js repository, there are an overwhelming number of issues and bugs. It appears that new features are being released in an unfinished state, and due to the high level of user dissatisfaction, many users are migrating to Remix.
The developer mentioned that the cache component, the subject of this post, likely needs to be redesigned because there are many aspects that were not actually considered. Therefore, I believe it is absolutely forbidden to use PPR and the cache component features in business applications for now. This is because, while the PPR method offers a better user experience than traditional SSR Streaming, it has too many critical bugs. Furthermore, even if we migrate to the cache component, I suspect the API might change due to the redesign.
I am also stuck with a bug after migrating to Next.js 16. I asked for help in the Discussions, but the response recommended using a different approach for now, stating that there is a bug with 'use cache' in Dynamic Routing. It works correctly when self-hosting, but the bug prevents caching from working when deployed to a Vercel server. After going through this struggle multiple times, I’m starting to feel apprehensive about adopting the latest technology stack.










