Next.js App Router vs Pages Router, How to Choose
App Router or Pages Router for a corporate site rebuild? How routing, data fetching, caching and hosting differ, and how to choose without regretting it at launch.
Most corporate websites have no need for client-side JavaScript on the About page. The Pages Router sends it anyway, because every page component hydrates in the browser. That one architectural fact sits at the centre of the Next.js App Router vs Pages Router decision. It affects your Core Web Vitals, your caching strategy, your hosting bill and how quickly your team ships after launch.
This guide explains how the two models actually differ on a real rebuild, so you can check whether your supplier’s recommendation holds up.
Get a router and rendering plan matched to your content model, CMS and hosting before a single page is built.
Two routers, two mental models
The Pages Router maps files in a pages directory to URLs. Each file exports one React component, and that component is the unit of rendering, data fetching and hydration. Shared chrome lives in _app and _document, and head tags are set per page with next/head.
The App Router maps folders in an app directory to URL segments. Each segment can have its own layout, page, loading and error files, and layouts nest. The key change is that components are React Server Components by default. They render on the server and send HTML plus a serialised payload, not JavaScript. You opt individual components into the browser with the “use client” directive.
For a corporate site, this changes the cost of each page. A careers page with a filterable job list needs interactivity in one widget. Under the Pages Router, the whole page hydrates. Under the App Router, only the filter component does, and the header, footer, body copy and legal text stay as plain server-rendered HTML.
The question is not which router is newer. It is which unit of rendering matches your content: whole pages (Pages Router) or nested layouts with small interactive islands (App Router).
How does data fetching actually change?
In the Pages Router, data fetching is attached to the route through a small set of exported functions. getStaticProps runs at build time (or on revalidation), getServerSideProps runs on every request, and getStaticPaths lists which dynamic routes to pre-build. The rules are rigid, and that is a strength: any developer can open a page file and see exactly where its data comes from and when it is fetched.
In the App Router, any Server Component can be async and fetch its own data directly from the CMS, a database or an internal API. A pricing table fetches pricing. A related-articles rail fetches articles. There is no single entry point, so data dependencies sit next to the UI that uses them. Mutations move to Server Actions, which replace many of the small API routes a Pages Router project accumulates for forms and newsletter sign-ups.
The trade-off is discipline. Co-located fetching is easy to read but just as easy to scatter across fifty components that each call the CMS separately. A competent team will set conventions early: a typed data layer, request deduplication and a clear rule for which components are allowed to fetch at all. Ask to see those conventions before the build starts.
If you are still deciding between static generation and request-time rendering for your templates, our breakdown of SSR versus SSG covers the underlying choice. Both routers support both modes.
Caching: where most rebuilds go wrong
Caching is where the two routers differ most in practice, and where App Router projects have caused the most trouble.
The Pages Router caching model is simple. Statically generated pages are cached as HTML and refreshed through Incremental Static Regeneration, either on a timer with revalidate or on demand when the CMS sends a webhook. Editors publish, a webhook fires, the page regenerates. Most marketing teams understand this within an afternoon.
Early App Router releases added several layers of implicit caching on top of that: request memoisation, a data cache, a full route cache and a client-side router cache. Teams shipped sites where an editor’s change did not appear, and nobody could say which layer was holding the stale copy. Next.js has since changed course. Its Next.js 16 release notes introduce Cache Components, built around a “use cache” directive, and state that, unlike the implicit caching in earlier App Router versions, this caching is “entirely opt-in”. Dynamic code now runs at request time unless you explicitly cache it.
That matters for a corporate rebuild in three ways:
- Predictability: you declare what is cached at the page, component or function level, and the compiler generates the cache keys.
- Partial prerendering: a page can be mostly static (hero, copy, navigation) with dynamic holes wrapped in Suspense, such as a localised office finder or a signed-in banner. Under the Pages Router, a page is either static or dynamic as a whole.
- Explicit invalidation: revalidateTag() now takes a cache lifetime profile for stale-while-revalidate behaviour, and a new updateTag() gives read-your-writes semantics inside Server Actions. A tag-per-content-type strategy maps neatly onto CMS webhooks.
The practical test for any supplier: ask them to explain, for one template, exactly what happens between an editor pressing Publish and a visitor seeing the change. If the answer involves “clearing the cache” without naming which one, keep asking.
SEO and Core Web Vitals in practice
Neither router is inherently better for rankings. Both render complete HTML on the server, so crawlers receive real content. The differences are in how much JavaScript follows that HTML and how metadata is managed.
On JavaScript weight, the App Router has a structural advantage. Server Components send no component code to the browser, so content-heavy templates ship less script, hydrate less and leave the main thread freer. That tends to help Interaction to Next Paint on mid-range mobile devices, which is where corporate sites usually fail. The benefit disappears if developers put “use client” at the top of every layout out of habit, which is the most common App Router anti-pattern we see in audits.
On metadata, the App Router’s Metadata API (a static metadata export or an async generateMetadata function) replaces hand-written next/head tags. File conventions such as sitemap.ts, robots.ts and opengraph-image generate those assets from the same data source as the pages. On a site with thousands of URLs across several locales, that removes a whole category of drift between the CMS and the sitemap.
Navigation also improved in the latest release. The Next.js 16 release notes say layout deduplication means a page with 50 product links now prefetches the shared layout once rather than 50 times. Ask your team to confirm the rendered HTML and metadata in Google Search Console’s URL Inspection tool on staging, not just in a browser.
The App Router does not make a site fast. It makes a fast site possible with less effort, provided client components are treated as the exception rather than the default.
Deployment and hosting differences
Both routers run on Vercel without configuration, and both can be self-hosted as a Node.js server or in a Docker container. Both also support a fully static export, though that removes ISR, request-time rendering and Server Actions.
The differences appear at enterprise scale. If you run several instances behind a load balancer on AWS, Azure or Kubernetes, the default cache lives on each instance’s file system. Without a shared cache handler (Redis is a common choice), one instance serves the updated page while another serves the old one. This affects ISR in both routers, but the App Router has more to cache and more to invalidate, so it needs more care.
A few other points from the Next.js 16 release are relevant to infrastructure teams. Middleware has been renamed to proxy.ts to make the network boundary clearer. The minimum Node.js version is now 20.9. A Build Adapters API, still in alpha, lets hosting platforms hook into the build output. If your security team controls the runtime image, raise these early.
Build speed matters to developer experience too. Turbopack is now the default bundler, and the Next.js 16 release notes report 2-5x faster production builds. On a large multi-locale site, that is the difference between editors waiting minutes or seconds for a preview deployment. For the wider platform picture, our enterprise web development guide covers environments, governance and release management.
A decision framework for your rebuild
For a brand-new corporate site, the App Router is the sensible default. New framework capabilities (Server Components, Cache Components, partial prerendering) are built for it. The harder call is for an existing Pages Router site, or a team with no App Router experience. Work through it in this order:
Staying on the Pages Router is a legitimate choice when the site is stable, the team is productive and the business case for rebuilding is weak. It is still supported. It is simply not where new capabilities are going. If you are also weighing whether Next.js is right at all for a mostly static marketing site, compare it with Next.js versus Astro. If the site currently runs on legacy PHP or .NET, an incremental Next.js migration can run alongside the existing platform.
Your next step: before you approve a proposal, ask the supplier for a one-page caching contract and an interactivity map for your three highest-traffic templates. If they cannot produce them, they have not yet designed the system you are paying for.
Audit the interactivity map:
List every template and mark which parts genuinely need client-side state. If almost everything is static content with a few forms, the App Router’s reduced JavaScript pays off. If the site behaves more like an application, the gain is smaller.
Check your dependencies:
Confirm your CMS SDK, analytics, consent manager, A/B testing and component library work inside Server Components or can be isolated in client components. CSS-in-JS libraries that depend on runtime injection are the usual blocker.
Define the caching contract:
Agree in writing which content types are cached, how long they live, which tags invalidate them and which CMS webhook triggers each tag.
Decide on hosting before you build:
Managed platform or self-hosted, single instance or many. Multi-instance self-hosting needs a shared cache handler budgeted from the start.
Choose the migration path:
Both directories can coexist in one project, so an existing site can move route by route. Start with low-risk templates such as legal pages or the blog, measure field Core Web Vitals, then move high-traffic templates.
Assess team readiness honestly:
The server and client boundary is a new mental model. A team fluent in the Pages Router can ship a solid site with it. A team learning the App Router mid-project will need senior review on every client boundary.
Frequently asked questions
Is the Next.js Pages Router deprecated?
No. The Pages Router is still supported and documented, and existing sites can keep running on it. New capabilities such as React Server Components, Cache Components and partial prerendering are built for the App Router, so new projects should normally start there.
Can the App Router and Pages Router run in the same project?
Yes. The app and pages directories can coexist, which allows a route-by-route migration. The same route should not exist in both, and navigating between a Pages Router route and an App Router route triggers a full page load rather than a client-side transition.
Is the App Router better for SEO than the Pages Router?
Not inherently, because both render full HTML on the server. The App Router helps indirectly by shipping less client-side JavaScript, which supports Core Web Vitals, and through its Metadata API and sitemap and robots file conventions, which reduce metadata errors on large sites.
Does the App Router cache everything by default?
Earlier App Router versions applied several layers of implicit caching, which caused stale content problems. In Next.js 16, Cache Components make caching opt-in through the “use cache” directive, and dynamic code runs at request time unless you explicitly cache it.
Do I need Vercel to run a Next.js App Router site?
No. App Router sites can be self-hosted as a Node.js server or in Docker on any cloud. If you run multiple instances, configure a shared cache handler so every instance serves the same revalidated content.
Choose your Next.js router with a clear plan
You now know where the App Router and Pages Router differ on rendering, caching and hosting, and which questions expose a weak proposal. Moburst Digital Experience can map your templates, caching and infrastructure into a migration plan your team can approve with confidence.