The short version

The headline argument for server-side rendering is search visibility, and behind a login no crawler ever looks. What remains is a narrower, genuine case: a faster first paint on slow devices, and less logic shipped to the browser. Set against it is a cost the public benchmarks hide — a personalised page cannot be cached. A marketing page renders once and serves millions; a dashboard renders per user, per request. Decide the public surface and the authenticated one separately, because they are not the same question.

Rendering strategy is one of the few architectural decisions that gets made early, gets made once, and is expensive to revisit. It is also discussed almost entirely through material written about public web pages, which is a different problem to the one most business applications have.

If what you are building sits behind a sign-in, a good deal of the standard advice simply does not apply to you.

The headline argument does not apply

Server-side rendering is overwhelmingly advocated on search grounds: a crawler receives finished HTML rather than an empty shell, so the page can be indexed properly.

A crawler cannot sign in. It will never see your dashboard, your admin console, your customer portal or your internal tool. Every search-related benefit of server rendering is, for those pages, worth precisely nothing.

This sounds obvious written down. It is nonetheless the reason a great many authenticated applications were built on a framework chosen for a benefit they cannot receive — because the decision was made by reading about rendering strategy in general, and almost everything written about rendering strategy is about public pages.

What is actually left

Two real benefits survive the login screen.

First meaningful paint on constrained devices. A client-rendered application sends a shell, which downloads a bundle, which executes, which then requests data, which finally renders. On a fast laptop that chain is imperceptible. On a mid-range Android phone on a slow connection it is seconds of blank screen. If your users are field staff, or customers in markets where the median device is not a flagship, this is the strongest argument available and it is a genuinely good one.

Keeping logic off the client. Rendering on the server means the browser receives the result rather than the means of producing it — fewer data shapes exposed, less business logic shipped. Worth being precise about what this is: a reduction in incidental exposure, not a security control. Anything the client must not decide has to be enforced server-side regardless, exactly as in a banking app's architecture. Server rendering does not change where enforcement lives.

Both are real. Neither is the reason most teams think they chose it.

THE SAME TECHNIQUE, TWO DIFFERENT ECONOMICS PUBLIC PAGE identical for everyone renders once cached at the edge served to millions crawlers index it cost scales with pages the benchmarks measure this AUTHENTICATED PAGE different for every user renders per request cannot cache at the edge served to one person never crawled cost scales with traffic nobody benchmarks this DECIDE THE TWO SURFACES SEPARATELY THEY ARE NOT THE SAME QUESTION, AND ONE ANSWER RARELY FITS BOTH
Personalisation is what removes the cache, and the cache is what made the public case cheap.

The cost nobody benchmarks

Here is the asymmetry that matters, and it is about caching rather than rendering.

A public page is the same for everybody. Render it once, put it in a CDN, serve it to a million people from the edge. The render cost is trivial because it is amortised across every visitor. That is why server rendering looks almost free in published comparisons.

An authenticated page is different for every single user. It cannot be cached at the edge and handed to the next person, because the next person must not see it. So every request is a render: fetch this user's data, compose their HTML, send it to exactly one person. The cost now scales with traffic rather than with the number of pages you have.

There are mitigations — cache the shared fragments, stream the personalised parts, push user-specific sections to the client after an initial shell — and they all amount to reintroducing some client rendering. That is a reasonable place to land. It is simply worth arriving at it deliberately rather than discovering under load that the render tier is now your capacity constraint.

The operational weight

A client-rendered application is, at deployment, a pile of static files. They can sit on a CDN, they fail rarely, and a bad release rolls back by swapping the files.

Server rendering replaces that with a running system in the request path of every page view. It needs capacity planning, memory headroom, monitoring and an on-call story. It holds session state. When it is unhealthy nothing renders at all, whereas a failing API in a client-rendered app usually degrades one panel.

For a team that already operates services this is marginal. For a team whose web tier was previously a bucket behind a CDN, it is a genuine addition to what they run — and it belongs in the decision alongside the performance numbers, which is the same argument we make about self-hosting anything else.

When client rendering is simply better

Worth saying plainly, because the current fashion runs the other way: for a long-lived authenticated session, a client-rendered application is often the better experience.

If someone signs in at nine and works in the application until five, they pay the initial load once and every navigation afterwards is instant, with no server round trip. For a dense internal tool with heavy interaction, that is exactly the right shape.

The question that decides it is not technical. It is whether users arrive once and stay, or arrive repeatedly for brief visits. Long sessions favour the client; short frequent visits favour the server. Nobody can answer that from the architecture diagram, which is why it should be asked of whoever knows the usage pattern.

A reasonable default

  1. Split the surfaces. Marketing, docs and anything public: server-rendered and cached, no argument needed.
  2. Decide the authenticated side on your users' devices, not on what the framework's homepage says.
  3. Measure the first load on a mid-range phone on a throttled connection, not on the laptop it was built on. This single test settles most of these debates.
  4. If you server-render authenticated pages, plan the render tier's capacity against concurrent users rather than page count.
  5. Keep enforcement server-side regardless. Rendering location is not a security boundary.

The frameworks are all good now, which is precisely why the decision should be made on your traffic and your users rather than on their relative merits. The wrong choice here is rarely a wrong framework; it is the right framework applied to the wrong half of the product.

Questions we get asked

Does SSR help SEO for an app behind a login?

No, and this matters because SEO is the headline argument in most material advocating server-side rendering. A crawler cannot authenticate, so it never sees an authenticated page and cannot index it. If your application is entirely behind a login, every search-related benefit of SSR is irrelevant to it, and the decision has to rest on the other reasons.

What does SSR actually buy you behind authentication?

Mainly a faster first meaningful paint on slow devices and poor networks, because the browser receives content rather than a shell that must fetch and then render. Secondarily it keeps logic and data shapes off the client. Both are real. Both matter most for users on low-end hardware, which is a question about your actual users rather than about the framework.

Why is caching harder for authenticated pages?

Because the output is different for every user, so it cannot be cached at a CDN and served to the next person. A public marketing page renders once and is served to everyone; a dashboard renders per user per request. The published benchmarks that make SSR look cheap are almost always measuring the public case, which is the one that caches.

Is a single-page app the wrong choice for a dashboard?

Not inherently. For a long-lived session where a user navigates many screens after signing in, a client-rendered application can feel faster after the first load, because subsequent navigation avoids a round trip. The cost is that first load. The honest question is whether your users arrive once and stay, or arrive repeatedly for short visits.

What does SSR cost operationally?

You move from serving static files to running a rendering server that scales with traffic, handles sessions, and becomes a dependency of every page view. Static assets fail rarely and cheaply. A render tier is a live system that needs capacity planning, monitoring and a deployment story, and that operational weight is the part most comparisons leave out.

How should we decide between rendering strategies?

Separate the public surface from the authenticated one and decide each on its own terms. Marketing pages, documentation and anything a crawler should see benefit clearly from server rendering and cache well. For the application behind the login, decide on your users' devices and networks and on whether sessions are long or short, rather than inheriting the decision from the public side.

Related service Web development Web applications that hold up under load

If you are choosing a rendering strategy for something mostly behind a sign-in, the test worth running first is the first load on a mid-range phone on a throttled connection. It settles the argument faster than any benchmark, and it is where we start on web application projects.