Server-side rendering
A web-rendering technique in which a server generates a user interface’s markup or other rendered representation before delivering it to a client.
Web Component Development with Modern Libraries and Tooling
The technique of generating a web application's HTML on a server before sending it to a client.
- How it is used
- Uses SSR to deliver initial web-component content sooner and make it more reliably available to search crawlers.
- How deep it goes
- Works through vanilla DSD markup and client behavior, then outlines Lit, Stencil, and wrec setup and rendering calls.
- Examples
- Shows a greeting component returned by an HTTP endpoint and a radio group whose server-rendered buttons gain change handling.
- What you can do after
- Build it from scratch with a DSD template and shared content function, or apply it via Lit, Stencil, or wrec.
Modern Angular
Server-side rendering is the generation of an application's initial HTML on a server before it is delivered to the browser.
- How it is used
- Improves public Angular pages whose initial-load performance and SEO matter more than internal enterprise-tool startup time.
- How deep it goes
- Walks through CLI creation, generated server architecture, local verification, hydration, and deployment constraints without deeply customizing the server.
- Examples
- Uses an HRMS promotional page, rendered title binding, clickable title-change button, generated configuration, and inspected response HTML.
- What you can do after
- Build it from scratch with Angular CLI, verify server-rendered HTML locally, and deploy dynamic routes to Node.js-capable hosting.
Vanilla Web
Generating HTML on a server for delivery to a browser.
- How it is used
- Uses request-time HTML to give a route meaningful content before client-side rendering.
- How deep it goes
- Defines the request-to-template flow and contrasts routing responses, but does not implement an SSR server.
- Examples
- Illustrates database-backed articles or products rendered into templates and contrasts route-specific HTML with an SPA shell.
- What you can do after
- Evaluate/understand when route-specific server HTML better serves public content than a shell-only SPA.
Fast by Default
Server-side rendering generates a user interface's HTML on a server before sending the rendered content to the client.
- How it is used
- Uses SSR to improve visible web content delivery when client-side JavaScript delays initial UI.
- How deep it goes
- Defines SSR, contrasts its waiting model with CSR and progressive approaches, and identifies slow server data as its limiting factor.
- Examples
- Illustrates SSR through DoorDash's Next.js migration for mobile users, reporting homepage and store-page LCP improvements.
- What you can do after
- Evaluate/understand SSR trade-offs against CSR, streaming SSR, and islands for users, data latency, and existing architecture.
React in Depth
Server-side rendering is the process of producing application interface output on a server before sending it to the client.
- How it is used
- Uses server-generated, data-filled HTML to improve the initial page display of React websites.
- How deep it goes
- Explains first-load and subsequent-navigation data flow, then shows route-data implementations; leaves framework details beyond the examples aside.
- Examples
- Compares an empty Vite root with server-generated HTML and implements a parameterized shop-category route in Next.js and Remix.
- What you can do after
- Apply it via Next.js getServerSideProps or a Remix loader to deliver route data in initial HTML while checking hydration constraints.
ASP.NET Core in Action, 3e
Server-side rendering is the process of generating HTML on the server before sending it to a client.
- How it is used
- Generates browser-facing HTML pages for traditional applications, while allowing APIs and other paradigms to coexist.
- How deep it goes
- Explains request, form, and markup generation, including Tag Helpers and CSRF protection, but stops short of rendering internals.
- Examples
- Uses Razor Pages templates, browser URLs, submitted forms, generated HTML, and Tag Helpers for labels, inputs, selections, and validation.
- What you can do after
- Builds browser-facing Razor Pages applications and selects them appropriately against APIs or client-side frameworks.
Read how ASP.NET Core in Action, 3e explains server-side rendering →
React Quickly, Second Edition
Server-side rendering is the generation of user-interface markup on a server before it is delivered to a client.
- How it is used
- Positions server-side rendering as a way to serve pre-rendered React HTML while retaining client-side interactivity.
- How deep it goes
- Defines the server-to-browser rendering flow and contrasts frameworks, but does not walk through an implementation.
- Examples
- Illustrates a server-rendered list with browser-based filtering and sorting, and names Next.js and Remix.
- What you can do after
- Evaluate/understand it as an option when choosing between server-rendered, static, and client-side React websites.
Read how React Quickly, Second Edition explains server-side rendering →
Rust Servers, Services, and Apps
Server-side rendering is a web application pattern in which a server generates a fully rendered web page and sends it to a browser.
- How it is used
- Builds a Rust web frontend for registration, login, data views, and CRUD operations through web forms.
- How deep it goes
- Traces templates, handlers, forms, and rendered responses; leaves SPA development for later and excludes PWAs.
- Examples
- Uses bank home and account pages, plus tutor course listings and details, to illustrate static and dynamic content.
- What you can do after
- Apply Actix Web and Tera to render dynamic pages, process form submissions, and display data-backed lists.
Read how Rust Servers, Services, and Apps explains server-side rendering →
Build a Frontend Web Framework (From Scratch)
A rendering approach in which the server generates the HTML for an application before sending it to the browser.
- How it is used
- Uses a backend to generate route-specific HTML before the browser handles interactions and state-driven updates.
- How deep it goes
- Defines the request, component, rendering, and hydration pipeline but stops short of implementation details.
- Examples
- Uses URL requests, route-selected components, loaded database data, generated HTML, and hydration flow diagrams as examples.
- What you can do after
- Understand how an SSR request becomes interactive browser markup through server rendering and hydration.
Read how Build a Frontend Web Framework (From Scratch) explains server-side rendering →
Pro Angular 16
Server-side rendering is the technique of executing an application on a server to generate HTML that is sent to a browser before client-side code is ready.
- How it is used
- Improves application delivery by displaying useful HTML while browser JavaScript downloads.
- How deep it goes
- Explains server execution, hydration, navigation changes, URL handling, commands, and testing, while deferring unsupported Angular features.
- Examples
- Uses SportsStore URL configuration, Angular Universal installation, anchor navigation, disabled controls, and JavaScript-disabled browser testing.
- What you can do after
- Operate/configure Angular Universal SSR, adapt browser-dependent code, test HTML-only output, and distinguish SSR from prerendering.
Acing the Frontend Interview
Server-side rendering generates an initial web-page representation on the server before sending it to the browser.
- How it is used
- Supports fast, dynamic, and SEO-friendly React experiences within scalable routing architectures.
- How deep it goes
- Defines SSR, contrasts CSR and SSG, and demonstrates request-specific data fetching without detailing server internals.
- Examples
- Uses a dynamic UserPage example that fetches a user from route parameters and renders UserProfile.
- What you can do after
- Evaluate rendering strategies and select frameworks that provide SSR, routing, data fetching, and performance optimizations.
Read how Acing the Frontend Interview explains server-side rendering →
Django in Action
Server-side rendering is the composition of a web page's HTML on the server before it is sent to a browser.
- How it is used
- Explains how Django turns a browser URL visit into completed HTML returned from a server.
- How deep it goes
- Defines the server-browser boundary and request flow, but stops short of implementation code or deployment details.
- Examples
- Uses a Django view selected by a URL and a template engine that combines reusable HTML pieces into a browser response.
- What you can do after
- Apply it via Django by connecting a URL to a view that renders a template and returns HTML to the browser.
Secrets of the JavaScript Ninja, Third Edition
A rendering technique in which HTML for a web page is generated on the server before being delivered to the browser.
- How it is used
- Uses server-generated HTML to deliver page content before browser JavaScript, addressing blank initial pages from JavaScript-heavy sites.
- How deep it goes
- Explains the rendering flow and shared-code constraint, while deferring implementation to frameworks.
- Examples
- Names Next.js, Remix, and Astro as React frameworks that render on the server by default and split page-specific JavaScript.
- What you can do after
- Understand how SSR changes initial page delivery and why its code must run in both server and browser environments.
Read how Secrets of the JavaScript Ninja, Third Edition explains server-side rendering →
Also covered in
- Build AI-Enhanced Web Apps
- Testing Spring Boot ApplicationsIn early access (MEAP)
- Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
- Road to Kubernetes
- Grokking Software ArchitectureIn early access (MEAP)
What to know first
- HTMLHTML is the standard markup language for structuring content and elements in documents on the web.
- JavaScriptJavaScript is a high-level, dynamically typed programming language standardized as ECMAScript and used for web and general-purpose programming.
- search engine optimizationSearch engine optimization is the practice of improving online content and structure so search engines can discover, interpret, and rank it prominently.
- CSSCSS (Cascading Style Sheets) is a stylesheet language for specifying the presentation and layout of structured documents.
Related concepts
- prerenderingalternative to · Prerendering is the generation of web-page HTML before it is requested or served, typically as prebuilt files.
- single-page applicationcontrasts with · A single-page application is a web application that loads a document and dynamically updates its content or interface without full-page navigation for most interactions.
- HTMLproduces · HTML is the standard markup language for structuring content and elements in documents on the web.
- client-side renderingcontrasts with · Client-side rendering is the generation or updating of a web interface in a user's browser by code executed there.
- template engineuses · A template engine is software that combines reusable templates with data and rules to generate rendered output such as text, documents, or user-interface views.
- declarative shadow rootused by · A declarative shadow root is a shadow DOM tree specified in HTML markup and attached by the browser during parsing.
Questions about server-side rendering
What is server-side rendering?
A web-rendering technique in which a server generates a user interface’s markup or other rendered representation before delivering it to a client.
Which Manning books explain server-side rendering?
Web Component Development with Modern Libraries and Tooling, Modern Angular, Vanilla Web, Fast by Default, React in Depth, ASP.NET Core in Action, 3e, React Quickly, Second Edition, Rust Servers, Services, and Apps and 5 more.
What should I know before learning server-side rendering?
Manning books that teach server-side rendering usually introduce HTML, JavaScript, search engine optimization and CSS first.
What is the difference between server-side rendering and prerendering?
A web-rendering technique in which a server generates a user interface’s markup or other rendered representation before delivering it to a client. Prerendering is the generation of web-page HTML before it is requested or served, typically as prebuilt files.
What is server-side rendering also called?
Server-side rendering is also called SSR or server rendering.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.












