Why Server Side Rendering is Better Than Client Side Rendering

Server Side Rendering in React

We’re officially in the age of server-side rendered React apps.

Companies like Netflix, Airbnb, and Uber have already adopted server-side rendering (SSR) as a powerful technique for building high-performance and secure React applications. In fact, according to Google, over 70% of websites built with React use SSR. In this article, we’ll take a closer look at SSR and explore why it’s becoming a game-changer for React development.

What is server side rendering?

Server-side rendering (SSR) is a technique for rendering web pages on the server and sending the pre-rendered HTML to the client instead of sending raw JavaScript and letting the client render the page. When a user requests a page, the server generates the HTML content. It sends it directly to the user’s browser, which can display it immediately without waiting for the JavaScript to execute.

Server-side rendering vs. Client-side rendering

To better understand server-side rendering, comparing it to client-side rendering (CSR), the more traditional approach used by most single-page applications (SPAs) built with React, is helpful. The following table summarizes some of the critical differences between server-side rendering and client-side rendering:

As you can see, server-side rendering has some clear advantages over client-side rendering regarding SEO, accessibility, and caching. Still, it can be slightly slower to load initially and requires more code complexity. But let’s go more in-depth.

What is SSR and CSR?

Server side rendering (SSR) and client side rendering (CSR) are two different approaches to rendering web pages with React.

In client-side rendering, the React application is loaded as a bundle of JavaScript files in the user’s browser. The JavaScript code runs on the client-side and renders the web page in the browser. When a user requests a new page, the browser fetches the data from the server via APIs and re-renders the web page with the new data. This approach is also known as single-page applications (SPAs).

In contrast, server side rendering generates the HTML content on the server and sends it to the user’s browser. The React application is still loaded as a bundle of JavaScript files, but it runs on the server instead of the client. When a user requests a page, the server generates the HTML content. It sends it directly to the user’s browser, which can then display it immediately without waiting for the JavaScript to execute. This approach is also known as universal or isomorphic applications.

Advantages and Disadvantages of SSR and CSR

Both approaches have their advantages and disadvantages.

What is SSR good for?

1. Improved Performance and Faster Load Times: One of the most significant benefits of React server side rendering is faster page load times. With server-side rendering, the server generates the initial HTML. It sends it to the browser, which can render it immediately without waiting for any JavaScript to download or execute. By pre-rendering pages on the server, server side rendering can significantly reduce the time users have to wait before they can see and interact with the content of a web page. This can lead to significantly faster page load times and a better user experience.
2. Better SEO: Another significant advantage of server-side rendering is improved search engine optimization (SEO). Search engines rely on the HTML content of a page to index it correctly. Server-side rendering allows search engines to crawl and index the fully rendered HTML, when all of the HTML content is available from the initial page load. As a result, this can improve the page’s visibility and ranking in search results and make it easier for search engines to index and for screen readers to navigate.
3. Better Accessibility: Server-side rendering can also improve the accessibility of React applications. With client-side rendering, users who have JavaScript disabled or are using assistive technologies may have difficulty accessing the page’s content. In contrast, server-side rendering ensures the content is available to all users, regardless of their browser or device.
4. Easier Maintenance and Scaling: Because server side rendering generates the HTML content on the server, it can simplify the development and maintenance of complex React applications. Additionally, server side rendering can make it easier to scale applications by reducing the server-side load.
5. Enhanced User Experience: Finally, server-side rendering can improve the overall user experience of React applications. By providing faster page load times, better SEO, improved accessibility, and enhanced security, SSR can create a more seamless and enjoyable user experience. Users can access the content they need more quickly, and the application is more accessible and secure, making it easier to use and trust.

What is SSR not good for?

Although server-side rendering offers many advantages for React applications, it may not be the best choice for every situation. Here are some scenarios where SSR might not be the best fit:

1. High-Traffic Websites: If a website has a high volume of traffic, SSR may not be the most efficient option as it can be resource-intensive for the server to generate and render pages on the fly. In this case, a hybrid approach combining SSR with client-side rendering may be a better option.
2. Complex Client-Side Interactions: If the application relies heavily on client-side interactions such as user input, real-time data updates, or dynamic UI components, SSR may not be the most suitable option. These interactions may require frequent re-renders, making the server-side rendering process slower and less efficient. In this case, CSR may be the better option.
3. SEO-Heavy Websites: While SSR can significantly improve a website’s SEO by serving fully rendered HTML pages to search engines, it may not be necessary for every website. If a website has minimal SEO requirements or is primarily an internal application, CSR may be a more suitable option.
4. Time-Sensitive Applications: If the application requires real-time data or displays information that changes frequently, SSR may not be the most efficient option. In this case, CSR can offer faster updates and a more responsive UI.

It’s important to carefully consider the needs of the application before deciding whether SSR is the best option. In some cases, a hybrid approach or CSR may be a better fit for the specific requirements of the application.

Pros and Cons of SSR Table

What is CSR good for?

While server-side rendering (SSR) has many benefits, client-side rendering (CSR) also has its place in web development. CSR is a technique where the server sends an empty HTML page with a single JavaScript bundle that loads and renders the entire app on the client-side. Here are some scenarios where CSR might be a good fit:

1. Interactivity: CSR is great for applications that require a high degree of interactivity and dynamic updates. Because the rendering happens on the client-side, CSR can offer a more seamless user experience than SSR. With CSR, users can interact with the app in real-time without waiting for the server to render each change. This makes it ideal for apps like social media platforms, chat applications, and real-time data visualization tools.
2. Progressive web apps: CSR is a popular choice for building progressive web apps (PWAs), which aim to deliver an app-like experience to users on any device. PWAs often use CSR to create a responsive and mobile-friendly UI. With CSR, PWAs can cache assets and data, making them available offline and improving performance. Additionally, PWAs can use features like push notifications and add-to-homescreen prompts to create a more native-like experience.
3. Single-page applications: CSR is ideal for building single-page applications (SPAs), which don’t require a full page reload for each user interaction. With CSR, SPAs can deliver a fast and fluid experience, making it a popular choice for modern web applications. Additionally, CSR allows for lazy loading, where components are loaded on-demand as the user interacts with the app. This helps to reduce the initial load time and improve performance.

What is CSR not good for?

Client-side rendering (CSR) can provide a more dynamic and interactive user experience, but there are some scenarios where it may not be the best choice:

1. SEO: One of the primary limitations of CSR is its impact on search engine optimization (SEO). Search engines primarily crawl HTML content, and CSR applications rely heavily on JavaScript to render content. This can lead to indexing issues, resulting in lower search rankings.
2. Performance on slower devices or connections: CSR can be more resource-intensive, which can lead to slower load times and poorer performance on slower devices or connections. This can result in a less optimal user experience, particularly for users on mobile devices or in areas with poor internet connectivity.
3. Accessibility: CSR can pose challenges for web accessibility. Since much of the content is rendered dynamically on the client-side, it can be difficult for screen readers and other assistive technologies to navigate and interpret the content.
4. Initial load times: While CSR can offer a more dynamic user experience once the page has loaded, the initial load time can be slower. This can result in a poor user experience, particularly for users who are not on high-speed connections.

Pros and Cons of CSR Table

While SSR is generally the preferred rendering technique for React applications, CSR has its place in web development and can be an effective choice for applications that require high interactivity, progressive web apps, and single-page applications. However, it’s important to weigh the advantages and disadvantages of both rendering techniques and choose the one that best fits your application’s unique needs.

Is server-side rendering better?

In general, the choice between SSR and CSR depends on the application’s specific requirements. If SEO and accessibility are necessary, or if the application has a lot of content that changes frequently, SSR may be the better choice. If the application requires a more responsive user experience or has a lot of dynamic user interactions, CSR may be the better choice. In some cases, a hybrid approach that combines SSR and CSR may be the best solution.

Here’s a video that compares the pros and cons of SSR and CSR as well:

How to Implement Server-Side Rendering

Implementing server-side rendering with React can seem daunting, but it can be a straightforward process with the right tools and knowledge. Here are the steps to implement server-side rendering in a React application:

1. Set up a server:

To implement server-side rendering, you’ll need to have a server that can run JavaScript code. You can use Node.js or any other server-side technology of your choice.

const express = require('express');
const app = express();

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

2. Install the required dependencies:

To enable server-side rendering, you’ll need to install the necessary dependencies. Some of the most popular ones include Express, React, ReactDOM, and Babel.

npm install express react react-dom babel-loader @babel/core webpack webpack-cli webpack-node-externals

3. Create a server-side entry point:

In order to run the React application on the server, you’ll need to create a server-side entry point. This file should include the necessary dependencies and render the React component to HTML.

import React from 'react';
import ReactDOMServer from 'react-dom/server';
import App from './App';

const html = ReactDOMServer.renderToString(<App />);

const template = `
  <!DOCTYPE html>
  <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>React Server-Side Rendering</title>
    </head>
    <body>
      <div id="root">${html}</div>
      <script src="bundle.js"></script>
    </body>
  </html>
`;

app.get('/', (req, res) => {
  res.send(template);
});

4. Configure webpack for server-side rendering:

You’ll need to configure webpack to build the JavaScript code for both the client and the server. This involves creating separate configurations for the client and the server, and using different loaders and plugins.

// webpack.client.config.js

module.exports = {
  entry: './src/index.js',
  output: {
    path: __dirname + '/public',
    filename: 'bundle.js',
  },
  module: {
    rules: [
      {
        test: /\\.(js|jsx)$/,
        exclude: /node_modules/,
        use: 'babel-loader',
      },
    ],
  },
};

// webpack.server.config.js

const nodeExternals = require('webpack-node-externals');

module.exports = {
  entry: './server/index.js',
  output: {
    path: __dirname + '/dist',
    filename: 'server.js',
  },
  target: 'node',
  externals: [nodeExternals()],
  module: {
    rules: [
      {
        test: /\\.(js|jsx)$/,
        exclude: /node_modules/,
        use: 'babel-loader',
      },
    ],
  },
};

5. Implement server-side rendering in your React components:

To ensure that your React components can be rendered on the server, you’ll need to modify them to use the ReactDOMServer.renderToString() method instead of ReactDOM.render(). This method returns the HTML content for the component, which can then be sent to the client.

import React from 'react';
import ReactDOMServer from 'react-dom/server';

function App() {
  return <div>Hello, world!</div>;
}

const html = ReactDOMServer.renderToString(<App />);

6. Set up routing on the server:

If your application has client-side routing, you’ll need to set up routing on the server as well. This involves mapping URLs to server-side components and rendering the appropriate component based on the URL.

app.get('/', (req, res) => {
  const html = ReactDOMServer.renderToString(<App />);
  const template = `
    <!DOCTYPE html>
    <html lang="en">
      <head>
        <meta charset="UTF-8">
        <title>React Server-Side Rendering</title>
      </head>
      <body>
        <div id="root">${html}</div>
        <script src="bundle.js"></script>
      </body>
    </html>
  `;
  res.send(template);
});

app.get('/about', (req, res) => {
  const html = ReactDOMServer.renderToString(<About />);
  const template = `
    <!DOCTYPE html>
    <html lang="en">
      <head>
        <meta charset="UTF-8">
        <title>About Us</title>
      </head>
      <body>
        <div id="root">${html}</div>
        <script src="bundle.js"></script>
      </body>
    </html>
  `;
  res.send(template);
});

Once you’ve completed these steps, your React application should be able to render on the server and send the HTML content to the client for display. With server-side rendering in place, you’ll be able to improve the performance and SEO of your application while providing a better user experience.

You can also follow this video tutorial as well for real time step by step guide:

It’s worth noting that several tools and frameworks can simplify the process of implementing server-side rendering with React. Some popular ones include Next.js, Gatsby, and Razzle. These tools provide pre-configured setups and simplify many of the steps outlined above, making it easier for developers to get started with server-side rendering.

Is SSR more secure?

Server-side rendering (SSR) can enhance the security of React applications by reducing the risk of security vulnerabilities. This section will explore why SSR is more secure than client-side rendering (CSR).

With client-side rendering, the initial HTML payload contains all the JavaScript code and sensitive information needed to render the application. This can be a security risk because attackers can access and exploit this information. For example, an attacker could steal sensitive data, inject malicious code, or tamper with the application’s functionality.

In contrast, server-side rendering only sends the necessary HTML and data to the client, reducing the amount of sensitive information exposed. The server can also apply additional security measures, such as input validation and authentication, before rendering the HTML. This can help reduce the risk of security vulnerabilities and protect the application and its users from potential attacks.

Another way that SSR can enhance the security of React applications is by enabling server-side access control. With client-side rendering, access control is often implemented in JavaScript, which attackers can bypass. In contrast, SSR allows access control to be implemented on the server, which is more secure and less vulnerable to attacks. This can help ensure that only authorized users can access sensitive data and functionality.

Server-side rendering is more secure than client-side rendering because it reduces the amount of sensitive information that is exposed and allows for more secure access control. By implementing SSR in your React application, you can enhance its security and protect it from attacks.

Add SSR in your Developing Tool Belt

Server-side rendering is a powerful technique that can significantly improve the performance, accessibility, and security of React applications. By generating the initial HTML payload on the server, SSR can reduce the amount of JavaScript code that needs to be downloaded and executed, resulting in faster page load times and a better user experience. SSR can improve your application’s visibility and accessibility to search engines and users with disabilities and enhance security by reducing sensitive information exposure. It’s important to evaluate your specific needs to determine whether SSR is the right choice, but given its significant benefits, it’s worth considering to improve your React applications.