Next.js Partial Prefetching Explained: Should You Enable It?
Next.js Partial Prefetching Explained: Should You Enable It?
What partialPrefetching: true vs false actually changes in Next.js 16.4+, when shared shells help, and when to leave…
·Updated on:··
⚡ Next.js Implementation Guides
In-depth Next.js guides covering App Router, RSC, ISR, and deployment. Get code examples, optimization checklists, and prompts to accelerate development.
I recently upgraded one of my projects to Next.js 16.4.6 and noticed a new warning during the build:
text
⚠ `cacheComponents` is enabled without a corresponding
`partialPrefetching` option.
Set `partialPrefetching` to either `true` or `false`.
I already had Cache Components enabled, so my first thought was to add partialPrefetching: true and move on.
But I wasn't sure what that option actually changed. Was it just another optimisation that Next.js wanted me to enable? And if so, why was false also a valid choice?
I looked into the documentation, and it turns out this is a more significant change than the warning makes it seem.
Partial Prefetching changes what Next.js downloads before someone clicks a link. Depending on how your application is structured, that can be a good thing. But it doesn't automatically make navigation faster.
What is Partial Prefetching?
First, a quick reminder of what prefetching does.
When you render a link using Next.js, the framework can start downloading the destination's data before the user clicks it.
For example, imagine a product listing with 20 products. Each product has a link to its detail page.
With the existing prefetch behaviour, Next.js can prefetch each destination separately as its link enters the viewport. That means multiple requests, potentially fetching content the user will never open.
The amount of content prefetched depends on how the destination is rendered and cached, but the important detail is that the prefetch is tied to a specific URL.
Partial Prefetching changes this.
Instead of fetching each destination individually by default, Next.js looks for the parts of the route that can be shared between different URLs. It calls this reusable content the App Shell.
When Partial Prefetching is enabled, Next.js can download that shared shell once and reuse it across links pointing to the same route.
The URL-specific content is left for navigation.
So instead of trying to prefetch 20 different product pages, Next.js might only need to prefetch the common structure used by those pages.
That's the main idea.
Think of it as separating the page structure from its content
Let's stay with the product listing example.
Imagine your application has a route like this:
text
/products/[slug]
Every product page uses roughly the same structure. There's a header, navigation, footer and a product detail section.
The header and footer might be identical across all products. But the actual product details depend on the slug.
With Partial Prefetching, Next.js tries to separate those two things.
The shared structure can be prefetched once, while the product-specific content is fetched when the user navigates to that product.
This is similar to how a client-side application can load a shared layout once and then fetch the content needed for a particular screen.
The difference is that Next.js works out which server-rendered parts can be shared, based on their dependencies and caching boundaries.
One important detail is that the App Shell isn't necessarily the entire page without its data.
It's the part Next.js can render without depending on the destination URL.
If most of your page depends on params, the reusable shell might be very small. In some cases, it could be little more than a loading fallback.
And that brings us to the main trade-off.
Fewer prefetch requests doesn't always mean faster navigation
At first, Partial Prefetching sounds like an obvious improvement.
Why fetch 20 different product pages when you can fetch their shared structure once?
That makes sense from a network and server-resource perspective.
But there's another side to it.
With the previous behaviour, Next.js might already have the destination's cached content ready by the time someone clicks a link.
With Partial Prefetching, the shared shell might be ready, but the product-specific content may still need to be requested.
The navigation can begin immediately because the shell is available. However, the content the user actually wanted might arrive later.
These are two different things:
How quickly the navigation starts and how quickly the meaningful page content appears.
Partial Prefetching optimises the way reusable content is fetched. It doesn't guarantee that the complete destination page will appear sooner.
For applications with lots of links pointing to the same route, the reduction in unnecessary prefetching can be substantial.
For applications where users benefit from having the full destination ready before clicking, the previous behaviour might still be preferable.
Neither approach is universally faster.
What do true and false actually change?
This is the part that wasn't immediately clear to me from the build warning.
In this case, Next.js can also resolve URL-specific data and include content available through its caching system.
It doesn't mean every dynamic request will be executed and the entire page will always be ready before the click.
Uncached dynamic content can still wait until navigation.
The point is that Partial Prefetching gives you a different default, while allowing individual links to request more content when that makes sense.
And if you explicitly use prefetch={false}, prefetching remains disabled for that link.
When does Partial Prefetching make sense?
I think the most interesting use case is an application with many links pointing to different URLs that share the same underlying route.
Product listings are a good example. So are article indexes, project galleries and other content-heavy pages.
Without Partial Prefetching, the browser may prefetch content for destinations the user never visits.
With Partial Prefetching, Next.js can reuse the same shell rather than fetching overlapping route structures repeatedly.
This becomes particularly useful when your routes have a meaningful amount of URL-independent content.
For example, a shared layout with navigation, common UI and cached components could be available immediately, while the individual page content loads separately.
You're spending less work preparing destinations the user might never open.
That's a reasonable trade-off for many applications.
When would I leave it disabled?
I wouldn't enable Partial Prefetching just because Next.js displays a warning.
Especially not in an existing application where navigation already works well.
One reason is that the shared App Shell might not contain much useful content.
In a CMS-driven application, the route often depends on a slug to determine which page to render. That slug might decide whether the destination is a product, an article, a project or something else entirely.
If most of the meaningful work depends on that parameter, there might not be much to share between different URLs.
Another reason is that you're changing how existing links behave.
If your application currently benefits from prefetching cached destination content, switching to shell-only prefetching might make some navigations feel different.
That doesn't mean Partial Prefetching is a bad choice. It means it's an architectural change rather than just a configuration cleanup.
For an existing project, I would rather make that decision separately from a routine framework upgrade.
A few gotchas worth understanding
Dynamic route parameters affect what can be shared
This one is easy to overlook.
Suppose your page needs to resolve params before it can decide what to render.
That work is URL-specific. Next.js can't simply reuse its result for every destination pointing to that route.
Suspense boundaries help determine which parts can be rendered independently and which parts need to wait for URL-dependent work.
If your route resolves parameters high in the component tree, before reaching a useful Suspense boundary, the reusable shell might contain less than you expect.
This is particularly relevant for dynamic routes like [slug] or [...slug].
Even if you use generateStaticParams(), the parameter values are still specific to the destination URL.
use cache doesn't automatically make content part of the shared shell
Cache Components and Partial Prefetching are related, but they solve different problems.
use cache lets Next.js cache the result of a component or function.
Partial Prefetching determines which rendered content can be shared across destinations during prefetching.
A cached product lookup can still depend on the product slug.
That means the result can be cached without becoming part of the URL-independent App Shell.
You can still prefetch that cached URL-specific content using an appropriate link configuration, but it isn't necessarily included in the default shared-shell prefetch.
An available loading state isn't the same as available content
This is probably the most important distinction.
You might enable Partial Prefetching, navigate between pages and notice that the transition begins immediately.
But if the shell only contains your layout and a loading skeleton, the user is still waiting for the main content.
It can feel like the page has started loading faster without actually delivering the content any sooner.
That's why I wouldn't evaluate Partial Prefetching solely by how quickly a navigation transition begins.
The important part is what the user sees after clicking.
So, should you enable it?
Partial Prefetching changes Next.js from prefetching individual destinations by default to prefetching reusable App Shells.
For applications with many similar routes, it can avoid repeated requests and unnecessary server work.
But it also changes when URL-specific content becomes available. Whether that's an improvement depends on how your routes, cached components and Suspense boundaries are structured.
In my case, I decided to keep:
ts
// next.config.tspartialPrefetching: false,
That resolves the warning while preserving the existing behaviour.
I'm not against enabling Partial Prefetching. I just don't think a framework upgrade warning is a good reason to change how navigation works throughout an application without first understanding the consequences.
Next.js is moving towards enabling Partial Prefetching by default in its next major release, so it's something worth understanding now.
The main thing I'll remember is that prefetching a shared shell and prefetching the page someone actually wants to open are not the same thing.
If you have questions or ran into a different gotcha, drop a comment below. And if you found this useful, subscribe for more.