React Server Components (RSC) and server-side rendering (SSR) are often treated as two names for one technique. They are not. SSR decides when and where a React tree is turned into initial HTML. RSC decides where component code can run and which code has to reach the browser at all. An application can use both at once: Server Components render first, the resulting tree is server-rendered to HTML, and Client Components are hydrated in the browser.
Two different questions
When developers ask about “server rendering” in React, they usually mean one of two separate things. The first is an output question: what HTML does the browser receive before any JavaScript runs? The second is an execution question: which components run on the server, which run in the browser, and which of their imports end up in the client bundle?
As an Amazon Associate I earn from qualifying purchases.
Traditional SSR answers the first question. React’s react-dom/server APIs “let you server-side render React components to HTML,” according to React’s server API reference. The browser gets markup quickly, and React then attaches event handlers to that markup during hydration.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →React Server Components answer the second question. React’s Server Components reference defines them as “a new type of Component that renders ahead of time, before bundling, in an environment separate from your client app or SSR server.” That sentence contains the key difference. A Server Component is not defined by producing HTML. It is defined by running in its own environment, separate from both the browser app and the SSR server, either during a build or for each request on a web server.
#1 Best Overall
What changed with Server Components
Components can run before bundling
In the RSC model, a Server Component can read data and produce output without its original component implementation, or the rendering libraries it depends on, being sent to the browser. React’s examples show this as the main practical difference: the code stays on the server side of the boundary.
The 'use client' directive marks a boundary
The 'use client' directive marks a module, and the dependencies it imports, as client code in the RSC module graph. A framework can server-render the root and other components that are safe to render on the server, while skipping evaluation of code imported from client-marked modules. The client then completes the tree. Components that need browser interaction, such as state, event handlers, or browser-only APIs, belong on the client side of this boundary.
Note what the directive does not do. It does not mark a Server Component. Server Components are the default in an RSC-enabled module graph, and the directive is what moves code across to the client. React’s React 19 release notes also state that there is no directive for Server Components. 'use server' belongs to Server Functions, which are a separate mechanism.
SSR remains a separate layer
Server rendering to HTML did not disappear. React supports streaming APIs for Node and Web Streams environments, and it keeps legacy non-streaming APIs with limited functionality. React 18 introduced renderToPipeableStream for Node streams and renderToReadableStream for modern edge runtimes, with streaming support for Suspense. For Node.js, React’s current API reference recommends the dedicated Node stream APIs over the Web Stream compatibility methods, which it says perform worse in Node.
How the layers fit together
| Layer | What it describes | What to know |
|---|---|---|
| Server Components | Where and when component code executes in the RSC architecture | Can run at build time or on a server per request. Their implementation does not need to be sent to the browser. |
| Client Components | Components that execute in the browser, marked through 'use client' module boundaries |
Appropriate for browser interaction such as state and event handling. |
| SSR | Producing initial HTML from a React tree on the server | Works with RSC. React documents streaming APIs as well as legacy non-streaming APIs. |
| Hydration | Attaching client React behavior to server-rendered HTML | Requires server and client output to match for server-rendered Client Components. |
| Server Functions | Client code calling async functions that execute on the server | Framework-mediated request. This is separate from what makes a component a Server Component. |
A typical combined request therefore has several stages. A Server Component runs and produces a serialized tree. The server renders that tree to HTML so the page appears before scripts load. The browser then hydrates the Client Components, and any user action that calls a Server Function makes a new request to the server.
Hydration is still where SSR apps break
Server-rendered Client Components still need the server HTML and the first client render to match. React’s React 19 release notes list several common causes of mismatches:
- Branches that run only in the browser, such as checks on
window - Calls to
Date.now()orMath.random()during render - Locale or timezone differences between the server and the browser
- External data that changes between the server render and the client render, without a snapshot to keep them consistent
- Invalid HTML nesting, which browsers may repair in the DOM before hydration runs
RSC does not remove any of these issues. It moves some code off the client, but any component that still hydrates on the client has to render the same result on both sides. Teams moving to Server Components often find the hydration checklist is unchanged for the components that remain interactive.
Why it matters in practice
RSC can keep server-side data access and rendering dependencies out of the client bundle, and it can make static content part of the initial page output without shipping the code that produced it. React’s documentation illustrates this with a Markdown page. In its example, the client bundle includes the marked library at 35.9K (11.2K gzipped) and sanitize-html at 206K (63.3K gzipped). The example says that a client-rendered version of this pattern would require downloading and parsing an additional 75K (gzipped) of libraries. These figures come from React’s documentation example, which uses a specific app and library set. They are not a benchmark, and they do not describe typical RSC applications.
RSC also gives a clearer way to combine server-side data access with interactive components. React documents async Server Components and Suspense streaming across server and client boundaries, so a page can show server-rendered content while interactive parts of the tree arrive later. The benefit depends on how the application is split into server and client parts. A page that is almost entirely interactive gains little from moving components to the server, because most of its code still has to run in the browser.
Where the trade-offs are
- Boundary design takes work. Each
'use client'module brings its imports into the client graph. A boundary placed high in the tree can pull large dependencies to the browser that a lower boundary would have avoided. - Serialization limits apply. Data passed from Server Components to Client Components has to be serializable. Objects with behavior, such as functions or class instances, cannot cross the boundary as they are.
- Debugging spans two environments. A failure can originate in the server render, in the serialized payload, or in client hydration, and the stack trace may not show which one.
- Framework dependence. Application code uses RSC through a framework or bundler, which implements the lower-level pieces.
API stability and framework support
React says the RSC features included in React 19 are stable. The underlying APIs that bundlers and frameworks use to implement RSC do not follow semantic versioning, and they may break between React 19 minor versions. React recommends that framework and bundler implementers pin an exact React version or use the Canary channel. Application developers who depend on a framework should follow that framework’s upgrade notes rather than assuming that a React minor release is safe to adopt on its own.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Recent changes to know about
The most recent React release shown in React’s official results is React 19.3, announced on September 9, 2026. Its notes describe a browser() helper for components that cannot produce meaningful UI during server rendering. They also describe a refinement that lets Server Components import and render Context from a 'use client' module. Server Components still cannot create Context. Check your framework’s version before relying on either change, because support depends on how the framework integrates the release.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsChoosing an approach
Compare the two approaches on these axes rather than on a single speed claim: the execution boundary (build time, per request, or browser), which code and dependencies ship to the client, initial HTML and streaming behavior, interactivity and hydration requirements, where data access happens, and how stable the framework support is.
Best Value
The useful question for a team is not whether to use RSC or SSR. Most applications that use RSC still use SSR for initial HTML. The question is which components should run on the server, which must hydrate in the browser, and whether your framework supports the boundary you need with an API that you are willing to pin.
Rendering HTML on the server and running components on the server are separate decisions. Keep them separate in your design and in your debugging, and the boundary between server and client code becomes much easier to reason about.
Official React documentation for the Server Components reference, the react-dom/server API reference, and the React 19 and React 19.3 release notes is the best place to check current behavior.
Recommended Free Tools
Quick Recap
The Bottom Line
“”
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
