Next.js in 2026: honest practitioner take on what's working and what isn't
By Nayan Kyada · · 5 min read
Part of Next.js Performance
Next.js in 2026 is the most powerful it has ever been, and the most exhausting to keep up with. Next.js 16 is the current major, and right now the framework sits in an interesting place: the core bets — React Server Components, Partial Prerendering, the App Router — are paying off in measurable ways, but the operational complexity has grown faster than the documentation explaining it.
This is not a hot take. It's a practitioner's reading of where things stand.
Where next.js in 2026 genuinely shines
RSC is finally the default mental model. The transition period where half your team was thinking in pages and the other half in server components is largely over for teams that committed early. On a typical marketing site with Sanity as the CMS, the entire content-fetching layer — GROQ queries, image URL building, structured data construction — can live in server components with zero client JavaScript for those paths. That keeps first-load JS small without heroic tree-shaking; the client bundle is mostly the interactive bits you actually opted into.
PPR is real and it changes how you think about dynamic content. In Next.js 16, Partial Prerendering comes through Cache Components (cacheComponents: true). The pattern is straightforward: the shell — header, hero, static copy — is prerendered and can be served from a CDN. Personalised or session-dependent content streams in behind a <Suspense> boundary. The static shell arrives fast, perceived load is dramatically better than a fully dynamic page, and you don't wait on the dynamic work before the first byte.
Turbopack is not nothing. It's now the default bundler, and on a medium-complexity codebase the difference in local cold start and hot reload is noticeable. I was skeptical of the benchmarks when they launched but the day-to-day experience difference is real.
The metadata API and image pipeline are mature. The generateMetadata function, next/image with Sanity's CDN, and the JSON-LD pattern using <script type="application/ld+json"> in a server component compose cleanly. I'm not fighting the framework on SEO fundamentals any more, which I was with the Pages Router's <Head> juggling.
Where it still hurts
Caching is genuinely hard to reason about. The layered cache model — request memoisation, Data Cache, Full Route Cache, client-side Router Cache — makes sense on a diagram. In production it produces bugs that are difficult to reproduce. A common one: a Sanity webhook fires, revalidatePath runs on the server, but a browser tab that already has the page in its client-side cache keeps showing the old version until a full navigation or refresh. Editors see the live update in Studio and then the old version in the open tab. You end up adding router.refresh() calls in client components as a patch. It works, but it's the kind of fix that signals the abstraction is leaking.
The 'use cache' directive — experimental in Next.js 15, and part of Cache Components in Next.js 16 — helps, because it makes caching explicit rather than implicit. But it also means you need to audit every existing fetch call to understand what behaviour you're actually getting in the new model versus what you assumed. On a mature codebase, that audit takes days.
Upgrade churn is a real cost, not a talking point. Next.js 13, 14, 15, and 16 each required meaningful changes to how routing, caching, async APIs, or component boundaries work. For a site running Sanity + Next.js + Vercel, a minor version bump is usually small. A major version bump with App Router changes can take days of work including testing, which you either absorb in the retainer or bill separately and have a conversation about. Some clients notice this. The framework's velocity is a feature for Vercel's competitive position, but it's a real cost for maintenance-phase projects.
Lock-in is not imaginary, but it's narrower than it used to be. You can self-host Next.js on a Node server or in a Docker container: the Next.js docs state Cache Components work with next start, and after() is fully supported when self-hosting. Where it gets harder is the infrastructure around those features — getting PPR's streaming and static-shell advantages through your CDN, sharing the cache across multiple instances, and on-demand revalidation at scale take real configuration work off Vercel. If a client asks me "what if we need to move off Vercel in two years", my honest answer is: the migration is possible but the bill for rewriting the infrastructure-coupled parts is real. That's a reasonable trade-off for most teams, but it should be an explicit decision, not an assumption.
The App Router's async patterns bite junior developers hard. async/await in server components, useEffect still available but often wrong, use client boundary placement, useActionState (formerly useFormState) for form mutations — the mental model requires understanding React's concurrent model reasonably well. Developers new to the App Router commonly spend their first week or so fighting hydration errors or misplaced 'use client' directives before the model clicks. The framework is not beginner-hostile, but it is complexity-hostile if you're not ready for it.
My actual position
I'm still choosing Next.js for every content site and marketing build I take on. The RSC + Sanity combination is genuinely the most productive setup I've found for the category of work I do. PPR has moved from "interesting experiment" to "default choice" on sites where the dynamic surface is bounded.
But I scope upgrade time into every maintenance contract, I document the Vercel dependency explicitly in proposals, and I don't reach for Next.js when a client has a Rails or Django backend team and wants a thin frontend — that's a better fit for React Router (formerly Remix) or even a simple SPA.
The framework earns its complexity for the right use case. The mistake is treating it as the default for every case.