Ecosystem●10 min read

Next.js vs React: Which One Should You Use?

●May 30, 2025●Updated on October 13, 2026
Next.js vs React

The Next.js vs React question is common in frontend planning, and the answer has shifted more in the last two years than in the previous five. React 19 shipped stable Server Components, the React team deprecated Create React App, and React's own documentation now tells you to start with a framework.

In brief:

  • React is a user interface (UI) library that, since React 19, includes stable Server Components and Server Functions, but it still needs a framework or bundler setup, a toolchain that processes and packages application code, for routing, server-side rendering (SSR), and data fetching.
  • Next.js 16 is a full-stack React framework with file-based routing, four stable rendering strategies, Turbopack as the default bundler, and opt-in caching.
  • Create React App is deprecated. The React team recommends Next.js, React Router v7, or Expo for new apps, and Vite or similar build tools for single-page applications (SPAs).
  • Both approaches work with Strapi 5 through auto-generated Representational State Transfer (REST) application programming interfaces (APIs). The optional GraphQL plugin and official @strapi/client software development kit (SDK) provide two other paths.

What React Is Today: More Than a View Layer

The React UI library builds user interfaces from reusable components. React 19 has been stable since December 2024 and includes Server Components, which render ahead of time in an environment separate from the client and are never sent to the browser, and Server Functions, which let client components call async functions that execute on the server. React's docs now describe this under the heading "Full-stack React Architecture".

React itself does not supply an application server. Server Components require a compatible bundler or framework, and the React docs describe Next.js's App Router as the "most complete implementation" of that architecture.

  • Create React App is gone as a starting point. The React team deprecated it in February 2025 and wrote that the project "currently has no active maintainers." Their rule of thumb from that post: "if your app needs routing, you would probably benefit from using a framework."
  • Manual memoization is fading as a complaint. React Compiler 1.0 reached stable release in October 2025, automates the performance work developers used to do with useMemo and useCallback, and works with React 17 and up.

For new projects, the official React docs recommend starting with Next.js (App Router) or React Router v7. They recommend Expo for universal Android, iOS, and web apps. Building a React app from scratch with Vite remains supported but is framed as an SPA-only path. Parcel and Rsbuild are supported for the same use case. The docs warn that adding SSR or static generation yourself "requires deep expertise to set up and maintain."

React on its own means a Vite-based SPA where you choose your own router and state management. You also choose a data-fetching approach, with data timing shaping the React rendering strategies available to you.

What Next.js 16 Adds on Top of React

The Next.js framework is built on React and is currently at version 16. See Next.js features and uses for additional framework details. The App Router is the default for new projects, and it changes several assumptions carried over from older tutorials:

  • Server Components by default. Layouts and pages render on the server unless you add the "use client" directive for state or event handlers. Browser APIs also require the directive. The "use client" directive marks the boundary between server and client components (Next.js docs). The App Router still renders the initial Hypertext Markup Language (HTML) on the server.
  • Route Handlers replace API Routes in the App Router for backend endpoints, and Server Actions let forms and event handlers call server-side functions directly.
  • Four stable rendering strategies: static generation (SSG), server-side rendering (SSR), streaming, and Incremental Static Regeneration (ISR), which updates static pages without a full rebuild. In Next.js 16, static and dynamic content can coexist within a single streaming response at the component level rather than per route. (Rendering philosophy). Our comparison of SSR vs SSG in Next.js explains when each fits.
  • Turbopack is the default bundler for both next dev and next build since Next.js 16, with webpack still available behind a flag.
  • Caching is now opt-in. Since Next.js 15, fetch requests and GET Route Handlers are uncached by default. Next.js 16's Cache Components model adds the use cache directive for explicitly caching functions and components. If you learned Next.js when everything cached aggressively by default, you'll need to account for that change.
  • Built-in image and font processing via the next/image component and next/font package, which self-hosts fonts so no runtime requests go to Google.

These defaults provide an integrated rendering and performance model, but they also require developers to understand server boundaries and explicit caching.

Next.js can start as a strict SPA with everything rendered client-side, then adopt server features progressively as the project grows.

Next.js vs React: Key Differences at a Glance

Next.js uses React, so the real decision is React on its own terms (typically a Vite SPA) versus React inside the structure Next.js provides.

AspectReact (Vite SPA)Next.js 16
Core purposeUI library plus build toolFull-stack framework built on React
RenderingClient-side rendering (CSR)CSR, SSR, SSG, ISR, and streaming
RoutingBring your own (React Router, TanStack Router)File-based App Router
API layerSeparate backend requiredRoute Handlers and Server Actions built in
SEOClient-rendered HTML; metadata needs extra workServer-rendered HTML and generateMetadata function
CachingYour responsibilityOpt-in via use cache directive, revalidateTag function, ISR guide
BundlerVite (Rolldown-based)Turbopack by default
Learning curveModerateSteeper: server/client boundaries, caching model
Best fitInternal applications, internal tools, minimum viable products (MVPs)Content sites, e-commerce, SEO-critical apps
Strapi 5 integrationREST, GraphQL, or @strapi/clientSame, plus ISR revalidation and Draft Mode

SEO and Performance: Where the Rendering Model Matters

Google executes JavaScript using an evergreen version of Chromium, per Google Search Central. Client-side rendering still has three documented SEO limitations:

  1. Rendering queue delay. Pages wait for rendering resources; Google says a page "may stay on this queue for a few seconds, but it can take longer than that."
  2. The app-shell problem. If the initial HTML contains no content, Google must run JavaScript before it can see anything, and content absent from the rendered output is not indexed.
  3. Other crawlers. Google's own guidance notes that "not all bots can run JavaScript," and its recommendation is direct: "server-side or pre-rendering is still a great idea because it makes your website faster for users and crawlers."

Performance follows a similar pattern. Per web.dev's client-side rendering guidance, CSR hides resources from the browser's preload scanner, which hurts Largest Contentful Paint (LCP), and unchunked client JavaScript can create long tasks that harm Interaction to Next Paint (INP).

Two practical rules fall out of this. If search visibility matters, render your HTML and metadata on the server, using generateMetadata in the App Router rather than client-side document.head manipulation; our Next.js SEO guide covers the implementation details, and headless setups have their own speed considerations on top. And if your app lives entirely behind a login and is not intended for indexing, these SEO trade-offs are usually irrelevant.

When to Use React, When to Use Next.js, and the Third Option

Your choice depends on whether you need SEO, server-side capabilities, and content workflows, or a lightweight client-side app with simpler deployment.

React (Vite SPA) Fits When

A React SPA fits when:

  1. You're building an authenticated internal application or internal tool, including an Admin Panel. There's nothing for crawlers to index, and CSR delivers a responsive experience for logged-in users.
  2. You're shipping an MVP against an existing backend API and want quick iteration with simple static deployment, or you need static-only or on-premise hosting where a Node.js server isn't an option.

Next.js Fits When

Next.js earns its extra complexity in four common situations:

  1. SEO drives revenue for marketing sites and editorial content, including documentation. Server-rendered HTML eliminates the app-shell problem and cuts rendering-queue exposure.
  2. You run a large content catalog. ISR keeps pages static for speed and revalidates them on demand. This avoids hours-long full rebuilds.
  3. You need server-only secrets or server-side data access. Server Components can use API keys without exposing them to the browser.
  4. Editors need preview workflows. Draft Mode bypasses caches for editors while visitors keep getting cached pages.

You should also account for the costs. Self-hosting multiple instances requires an external cache handler and a shared Server Actions encryption key, per the official self-hosting docs.

Next.js Alternatives: React Router v7, Astro, and TanStack Start

React's docs recommend React Router v7 as a framework in its own right: it absorbed Remix, supports SPA, SSR, and static pre-rendering modes, and pairs with Vite. The Astro framework is another strong option for content-heavy sites, and TanStack Start is a full-stack React option built on a different foundation; our roundup of alternatives to Next.js compares them.

On adoption: the Stack Overflow 2025 survey (49,009 respondents) put React usage at 44.7% and Next.js at 20.8%. State of JS 2025 found Next.js "dominating the meta-framework category" while "losing satisfaction at the exact same time," with a 39-point satisfaction gap behind Astro.

That divergence also matters if you're deciding what to learn rather than what to ship. Consider learning React first. Next.js is React, so components, props, state, and hooks are the foundation either way, and none of that knowledge is wasted. The App Router then adds server/client boundaries and file-based routing. Its caching model can challenge new Next.js developers, particularly around hydration errors: mismatches between the server-rendered HTML and the client render, and "use client" directives in the wrong file.

Connecting React or Next.js to Strapi 5

Whichever you pick, the headless architecture works the same way: as a headless content management system (CMS), Strapi manages content and serves it over an API; your React or Next.js app owns the presentation. Strapi 5 supports REST by default, with GraphQL and an official SDK available as optional packages.

Define your content structure before writing frontend code; our content modeling best practices and React best practices for CMS-driven apps cover the patterns that hold up as projects grow.

REST API (Available by Default)

Strapi auto-generates REST endpoints for every Content-Type. Two defaults trip up new integrations: the built-in Users and Permissions feature requires granting the Public role permission to use find and findOne because Content-Types are private by default, and Strapi relations, media, and components require explicit populate:

const response = await fetch("http://localhost:1337/api/articles?populate=*");
const data = await response.json();
console.log(data.data);

For production, private endpoints stay reachable with the built-in API token capability, which requires configuring and securely supplying a token as an Authorization: Bearer header.

Strapi's built-in Cross-Origin Resource Sharing (CORS middleware) defaults to origin: '*'; before production, you need to edit the Strapi middleware configuration to restrict origin to the allowed frontend domains.

Strapi 5 identifies documents by documentId; v4 used a numeric id, so you'll need to update any older example code accordingly.

GraphQL (Free, Optional Install)

The @strapi/plugin-graphql GraphQL plugin adds a GraphQL endpoint at /graphql. You should set depthLimit and maxLimit explicitly in production; both default to unlimited.

Official SDK (Free, Optional Install)

The @strapi/client package wraps Collection Type and Single Type operations in first-class methods. It also covers Media Library operations, which saves you hand-rolling fetch logic.

Next.js-Specific Strapi Workflows

Next.js also supports ISR revalidation and Draft Mode in a Strapi integration. ISR pairs well with Strapi webhooks, but the integration requires custom cross-system configuration: Strapi sends a configured webhook after a content event to a protected Next.js Route Handler. The handler authenticates the request and invokes revalidatePath or revalidateTag to invalidate and revalidate the frontend cache on demand. The hosting platform then serves the updated content.

For editorial preview, Strapi's basic full-screen Preview feature is plan-dependent and integrates with Next.js Draft Mode through a route handler and a PREVIEW_SECRET, with setup steps in our Strapi 5 preview with Next.js guide. The iframe-based Live Preview requires eligible Live Preview plans, specifically CMS Growth or Enterprise.

And if you're building with artificial intelligence (AI) coding agents, Strapi's built-in Model Context Protocol (MCP server) is generally available on any plan, turned off by default until you turn it on in config/server.ts.

Start Your React or Next.js Project with Strapi 5

You can also change your mind later. Next.js publishes an official incremental migration path that wraps an existing React app as a client-only SPA first, then converts routes one at a time.

Whichever frontend you choose, Strapi 5 stays constant on the backend. You can start with the npx create-strapi@latest command, model your Content-Types, and consume them from React or Next.js over REST or GraphQL. If you'd rather skip infrastructure work, Strapi Cloud handles hosting and a content delivery network (built-in CDN), with automated backups on Pro and above; Cloud pricing starts at $35 per project per month.

Paul BratslavskyDeveloper Advocate

Related Posts

Awesome Next.js Libraries
Ecosystem·14 min read

12 Next.js Libraries Worth Adding to Your Stack

Discover 12 Next.js libraries for data fetching, UI, forms, auth, and SEO that work with the App Router today—with current setup tips and Strapi integration.

·April 4, 2025
Tools & Concepts·7 min read

Advantages of using Next.js + Strapi vs React + Strapi

In this article, we’ll be looking at the advantage of using next.js and strapi over create-react app and strapi

·November 29, 2021
Next (React.js) and Strapi
How tosBeginner·33 min read

Build a blog with Next (React.js) and Strapi

Learn how to build a blog using Next.js (React.js) for the front-end and Strapi as the back-end.

·December 12, 2019