liveBook · Manning

Server-side rendering

Also called SSR, server 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.

How 13 Manning books explain it

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.

Read how Web Component Development with Modern Libraries and Tooling explains server-side rendering →

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.

Read how Modern Angular explains server-side rendering →

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.

Read how Vanilla Web explains server-side rendering →

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.

Read how Fast by Default explains server-side rendering →

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.

Read how React in Depth explains server-side rendering →

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.

Read how Pro Angular 16 explains server-side rendering →

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.

Read how Django in Action explains server-side rendering →

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

What to know first

Related concepts

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.