What is server-side rendering?
Server-side rendering (SSR) generates page HTML on a server in response to a request. It can make the main content available before browser JavaScript runs, while interactive features may still need JavaScript.
The important distinction is where and when HTML is produced. SSR runs at request time; static site generation produces HTML ahead of requests. Client-side rendering uses browser JavaScript to construct some or all of the interface. web.dev’s rendering overview describes the tradeoffs.
SSR is not another name for dynamic rendering. In Google’s terminology, dynamic rendering selects a separate rendered response for certain crawlers while users receive the client-rendered version. Google describes that approach as a workaround, rather than a recommended long-term architecture.
Why the initial HTML matters for search
When a page’s useful text and links are present in its HTTP response, accessing them does not depend on the browser first downloading and executing the application bundle. That is a useful design property for a public article or product description.
Google can run JavaScript and uses rendered HTML for indexing. Its rendering queue is resource-dependent; the documentation does not establish a fixed days-or-weeks delay. SSR does not exempt a page from rendering or guarantee indexing. Google’s JavaScript SEO documentation explains crawling, rendering and indexing.
Follow the request and the interaction
A typical request-time flow is: receive the request, fetch required data, generate HTML and return it. Some implementations stream HTML in chunks rather than waiting for the complete document. Hydration then connects browser code to server-rendered interface elements.
A page can therefore show a booking form before its date picker works. Seeing the heading is not proof that the page is ready for interaction. Test the initial response and the functional interface separately.
| Surface | Useful check | What it cannot establish |
|---|---|---|
| Initial response | Main text, links, metadata and HTTP status | Whether a browser-only widget works. |
| Rendered browser page | Interaction, errors and hydration behavior | What was present before JavaScript ran. |
| Search inspection | What Google can fetch and render | A guaranteed ranking or future crawl time. |
SSR, static generation and client rendering
An illustrative product page might prebuild its description and specifications, then fetch current stock in a browser widget. Another implementation might render stock on the server. Decide which information must be available at the first response, how stale it may be, and how updates reach the page.
A private dashboard has different requirements from a public catalog. Authentication and user-specific data matter there, while public search visibility may be irrelevant. A single website can use different approaches for these different tasks.
A concrete implementation example
Astro supports both build-time pages and on-demand rendering. Its on-demand rendering documentation explains how an adapter enables request-time routes and how individual routes can opt out of prerendering.
That distinction matters when someone says a site “uses an SSR framework.” The framework’s name does not prove that a particular route is rendered on demand. Check that route’s configuration, deployed response and runtime dependencies.
Server work, hydration and caching
Generating HTML can add server work before the first response; the effect depends on data access, rendering cost, caching and the deployed infrastructure. There is no universal extra millisecond amount, and earlier visible content does not automatically make interaction fast.
Caching introduces another decision: which visitors may safely share a response? Public product descriptions and signed-in account pages have different privacy requirements. Do not apply public HTML caching to user-specific content without an explicit isolation design.
Measure server response time alongside the page’s user experience metrics. A fast cache hit can hide a slow uncached request. Test both.
Review the actual route
- Compare the original HTML with the browser-rendered page for meaningful content and links.
- Check that missing resources return appropriate HTTP status codes rather than a successful blank shell.
- Keep initial and client-updated canonical metadata consistent.
- Investigate failed or blocked scripts and dependent API requests.
- Test keyboard interaction and labels as well as JavaScript-disabled content.
The JavaScript-disabled test is useful evidence of progressive delivery. It does not by itself validate hydration, assistive-technology behavior or what Google rendered.
Avoid architectural shortcuts
Do not call SSR a complete accessibility solution: server-generated markup can still have unlabeled controls or an unusable focus order. Conversely, JavaScript use alone does not establish an accessibility failure.
Also avoid moving every route to request-time rendering merely to improve SEO. Write down the route’s freshness, personalization and interaction requirements first. If the existing static page serves the reader correctly, changing its rendering mode creates new operational work that needs a clear benefit.
Additional questions
Does an SSR page need JavaScript?
It can deliver readable content without browser JavaScript, but its interactive components may still require it. The answer depends on how the route and its interface are implemented.
Is an SSR response always fresh?
No. Cached HTML and cached upstream data can be older than the request. Define an acceptable freshness policy and test the actual delivery path.
Can SSR guarantee indexing?
No. It can remove a dependency on browser execution for content included in the response. Fetchability, indexing directives, canonical selection and content remain separate concerns.
Related glossary terms
Sources
Primary documentation accessed on 12 October 2026. Example scenarios are illustrative, not customer results.