How to Set Up Server-Side Rendering with Node.js

Set up Server-Side Rendering (SSR) with Node.js. Follow our detailed guide to improve performance, SEO, and user experience in your Node.js applications.

Setting up server-side rendering (SSR) with Node.js can transform the way your web applications perform and interact with users. By rendering content on the server instead of the client, you can improve SEO, enhance performance, and deliver a better user experience. This guide will walk you through the process in a straightforward and detailed manner. Let’s dive in.

Understanding Server-Side Rendering

Server-side rendering (SSR) is a powerful technique that enhances web application performance, improves SEO, and provides a better user experience. Understanding the nuances of SSR is essential for businesses aiming to leverage this technology for strategic advantages.

Server-side rendering (SSR) is a powerful technique that enhances web application performance, improves SEO, and provides a better user experience. Understanding the nuances of SSR is essential for businesses aiming to leverage this technology for strategic advantages.

What is Server-Side Rendering?

Server-side rendering refers to the process of rendering web pages on the server instead of in the browser. When a user requests a page, the server generates the complete HTML content and sends it to the browser.

This contrasts with client-side rendering (CSR), where the browser downloads a minimal HTML shell and JavaScript code that builds the content dynamically.

In SSR, the server generates the HTML of a web page dynamically for each request. This means the user gets a fully rendered HTML page, which is then displayed by the browser. This immediate content availability enhances user experience, particularly for users on slower networks or devices with limited processing power.

Why Use Server-Side Rendering?

Improved SEO

Search engines play a critical role in driving traffic to your website. SSR offers a significant advantage in terms of search engine optimization (SEO). Search engine bots often struggle with JavaScript-heavy applications that rely on CSR.

By using SSR, you ensure that the search engine bots receive fully rendered HTML pages, making it easier for them to index your content accurately. This can lead to higher search engine rankings and increased visibility for your website.

Faster Time to First Paint

The time it takes for a web page to start displaying content after a user requests it is known as the time to first paint (TTFP). With SSR, the server sends a fully rendered HTML page, which the browser can display immediately.

This results in a faster TTFP, improving the perceived performance of your application. Users can see and interact with your content more quickly, leading to higher engagement and satisfaction.

Better Performance on Low-End Devices

Not all users have access to high-performance devices. For users on low-end devices, client-side rendering can be resource-intensive and slow. By offloading the rendering process to the server, SSR reduces the load on users’ devices, ensuring a smoother and faster experience.

This inclusivity can help you reach a broader audience and retain users who might otherwise abandon slow-loading pages.

Strategic Benefits for Businesses

Enhanced User Experience

Providing a seamless and fast user experience is crucial for retaining visitors and converting them into customers. SSR ensures that users can access your content quickly, without waiting for the JavaScript to load and execute.

This can significantly reduce bounce rates and increase the time users spend on your site. A positive user experience translates to higher customer satisfaction and loyalty.

Competitive Advantage

In the competitive online landscape, businesses need every edge they can get.

By implementing SSR, you can outperform competitors who rely solely on CSR. Faster load times and better SEO can help you attract more organic traffic and provide a superior user experience, setting your business apart from the competition.

Scalability and Flexibility

SSR with Node.js offers excellent scalability and flexibility. As your business grows, you can easily scale your server infrastructure to handle increased traffic.

Additionally, SSR allows you to integrate with various modern web development tools and frameworks, enabling you to build complex, feature-rich applications that can adapt to evolving business needs.

Improved Conversion Rates

Faster page load times and a better user experience can lead to higher conversion rates. Whether your goal is to generate leads, sell products, or encourage user sign-ups, SSR can help you achieve better results. Users are more likely to convert when they have a smooth and fast experience on your website.

Implementing Server-Side Rendering

Choosing the Right Framework

When implementing SSR, choosing the right framework is crucial. Node.js, combined with frameworks like Next.js, provides a robust foundation for SSR. Next.js, in particular, simplifies the setup and management of SSR, offering built-in features like automatic code splitting, static generation, and API routes.

Setting Up Your Development Environment

A well-configured development environment is essential for efficient SSR implementation. Ensure that you have Node.js and npm installed on your system. Use modern tools like Babel and Webpack to compile and bundle your code.

Create a clean and organized directory structure to separate server and client logic, making your codebase easier to manage and scale.

Rendering Components on the Server

To render React components on the server, use libraries like ReactDOMServer. By generating HTML on the server, you ensure that users receive fully rendered pages. Combine this with client-side hydration, where React takes over the server-rendered HTML, enabling interactive features.

Handling Data Fetching

Data fetching is a critical aspect of SSR. Ensure that your server-side code can fetch and render data before sending the HTML to the client. Use state management libraries like Redux to manage and pass data between the server and client seamlessly.

This ensures that users receive up-to-date content without additional client-side requests.

Managing State and Authentication

For dynamic applications, managing state and authentication is crucial. Use Redux to manage application state and Passport.js for authentication. By handling authentication on the server, you can secure sensitive routes and ensure that only authenticated users can access certain parts of your application.

Advanced Techniques and Best Practices

Code Splitting and Lazy Loading

To optimize performance, implement code splitting and lazy loading. Code splitting divides your code into smaller chunks that can be loaded on demand. Lazy loading defers the loading of non-critical resources until they are needed.

These techniques reduce the initial load time, improving performance and user experience.

Caching and Content Delivery Networks (CDNs)

To further enhance performance, use caching and CDNs. Cache rendered HTML pages to serve repeated requests quickly. Use CDNs to distribute static assets like images, stylesheets, and scripts across multiple servers worldwide, reducing latency and improving load times for users globally.

Monitoring and Analytics

Implement monitoring and analytics to track the performance of your SSR application. Use tools like Google Analytics, New Relic, or Datadog to monitor server performance, track user interactions, and identify bottlenecks. Analyzing this data helps you optimize your application and provide a better user experience.

Setting Up Your Node.js Environment

Setting up your Node.js environment is the first and one of the most crucial steps in implementing server-side rendering. This environment forms the backbone of your application, influencing its performance, scalability, and maintainability.

Setting up your Node.js environment is the first and one of the most crucial steps in implementing server-side rendering. This environment forms the backbone of your application, influencing its performance, scalability, and maintainability.

A well-configured environment ensures smooth development and deployment processes, enabling your business to deliver robust web applications efficiently.

Installing Node.js and npm

Before you begin, you need to install Node.js and npm (Node Package Manager) on your machine. Node.js provides a runtime environment for executing JavaScript on the server, while npm helps manage the packages and dependencies your project will require.

Visit the Node.js official website to download the latest version of Node.js, which includes npm. Follow the installation instructions for your operating system. Once installed, verify the installation by running the following commands in your terminal:

node -v
npm -v

These commands should display the installed versions of Node.js and npm, confirming that the installation was successful.

Creating Your Project Directory

Organizing your project files is critical for maintainability. Start by creating a dedicated directory for your project. This directory will house all the files and folders related to your server-side rendering setup.

Open your terminal and run:

mkdir ssr-nodejs
cd ssr-nodejs

This creates a new directory named ssr-nodejs and navigates into it.

Initializing npm

To manage your project’s dependencies and scripts, initialize npm within your project directory. This creates a package.json file that keeps track of the packages your project uses.

Run the following command in your terminal:

npm init -y

The -y flag automatically answers ‘yes’ to all prompts, creating a default package.json file. You can manually edit this file later to customize your project settings.

Installing Essential Dependencies

For server-side rendering with Node.js, you need several key packages. Install them using npm by running:

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

Here’s a breakdown of these packages and their roles:

  • Express: A minimal web framework for Node.js that simplifies server setup and routing.
  • React and React-DOM: Libraries for building and rendering user interfaces.
  • Babel: A JavaScript compiler that allows you to use modern JavaScript features.
  • Webpack: A module bundler that compiles your JavaScript modules into a single file.
  • webpack-node-externals: A utility to exclude Node.js modules from the Webpack bundle.

Configuring Babel

Babel allows you to write modern JavaScript code that is compatible with older environments. Create a .babelrc file in your project root to configure Babel:

{
  "presets": ["@babel/preset-env", "@babel/preset-react"]
}

This configuration enables Babel to transpile your JavaScript and React code.

Setting Up Webpack

Webpack bundles your JavaScript files into a single output file, which can be served to the client. Create a webpack.config.js file in your project root and add the following configuration:

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

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

This configuration specifies the entry point for your server-side code, sets up the output directory and file, and defines rules for processing JavaScript files using Babel.

Creating the Directory Structure

A well-organized directory structure enhances code readability and maintainability. Within your project directory, create a src folder. Inside src, create two folders: server and client. This separation of server and client code helps in managing and scaling your application.

mkdir -p src/server src/client

Setting Up Express Server

Express simplifies server setup and routing in Node.js. Create an index.js file inside src/server and add the following code:

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

const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.static('public'));

app.get('*', (req, res) => {
  res.sendFile(path.resolve('public', 'index.html'));
});

app.listen(PORT, () => {
  console.log(`Server is listening on port ${PORT}`);
});

This basic Express server serves static files from a public directory and handles all routes by sending an index.html file.

Creating React Components

React components form the building blocks of your user interface. Create a simple React component to render on the server. In src, create a components directory and inside it, a Home.js file:

import React from 'react';

const Home = () => (
  <div>
    <h1>Welcome to Server-Side Rendering with Node.js</h1>
    <p>This page is rendered on the server.</p>
  </div>
);

export default Home;

Rendering React on the Server

To render your React component on the server, use ReactDOMServer. Update src/server/index.js to include the following:

const express = require('express');
const React = require('react');
const ReactDOMServer = require('react-dom/server');
const path = require('path');
const Home = require('../components/Home').default;

const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.static('public'));

app.get('*', (req, res) => {
  const content = ReactDOMServer.renderToString(React.createElement(Home));
  const html = `
    <!DOCTYPE html>
    <html>
      <head>
        <title>Server-Side Rendering with Node.js</title>
      </head>
      <body>
        <div id="root">${content}</div>
        <script src="/bundle.js"></script>
      </body>
    </html>
  `;
  res.send(html);
});

app.listen(PORT, () => {
  console.log(`Server is listening on port ${PORT}`);
});

This setup creates an Express server that renders the Home component on the server and sends the HTML to the client.

Strategic Tips for Businesses

Setting up a Node.js environment for server-side rendering offers several strategic advantages for businesses. First, it enhances SEO by allowing search engines to index fully rendered HTML, improving your site’s visibility.

Second, it provides faster initial load times, offering a better user experience, which can lead to higher engagement and conversion rates.

Moreover, the modularity and scalability of Node.js allow businesses to easily expand their applications as they grow. By separating server and client logic, you maintain a clean codebase that is easier to manage and debug.

Incorporating modern tools like Babel and Webpack ensures that your code remains up-to-date with the latest JavaScript standards, making your application more robust and future-proof.

This strategic setup not only improves development efficiency but also positions your business to quickly adapt to new technologies and trends.

Building the Server

Setting Up Express

Express is a fast and minimal web framework for Node.js. Create a new directory named src and within it, create another directory named server. In src/server, create an index.js file with the following content:

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

const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.static('public'));

app.get('*', (req, res) => {
  res.sendFile(path.resolve('public', 'index.html'));
});

app.listen(PORT, () => {
  console.log(`Server is listening on port ${PORT}`);
});

This basic setup creates an Express server that serves static files from a public directory and handles all routes with a fallback to index.html.

Creating a React Component

Next, create a simple React component to render. In src, create a components directory and inside it, create a Home.js file:

import React from 'react';

const Home = () => (
  <div>
    <h1>Welcome to Server-Side Rendering with Node.js</h1>
    <p>This page is rendered on the server.</p>
  </div>
);

export default Home;

Rendering React on the Server

To render our React component on the server, we need to use ReactDOMServer. In src/server/index.js, update the file as follows:

const express = require('express');
const React = require('react');
const ReactDOMServer = require('react-dom/server');
const path = require('path');
const Home = require('../components/Home').default;

const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.static('public'));

app.get('*', (req, res) => {
  const content = ReactDOMServer.renderToString(React.createElement(Home));
  const html = `
    <!DOCTYPE html>
    <html>
      <head>
        <title>Server-Side Rendering with Node.js</title>
      </head>
      <body>
        <div id="root">${content}</div>
        <script src="/bundle.js"></script>
      </body>
    </html>
  `;
  res.send(html);
});

app.listen(PORT, () => {
  console.log(`Server is listening on port ${PORT}`);
});

At this point, we have set up a basic server that renders a React component on the server and sends the HTML to the client.

Enhancing Your Server-Side Rendering Setup

To enable interactivity on the client side, we need to bundle our React application using Webpack. Create a new file src/client/index.js and add the following content:

Building the Client Bundle

To enable interactivity on the client side, we need to bundle our React application using Webpack. Create a new file src/client/index.js and add the following content:

import React from 'react';
import ReactDOM from 'react-dom';
import Home from '../components/Home';

ReactDOM.hydrate(<Home />, document.getElementById('root'));

This file will hydrate the server-rendered HTML with React, enabling client-side interactivity.

Updating the Webpack Configuration

We need to update our Webpack configuration to bundle both server and client code. Update webpack.config.js as follows:

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

const serverConfig = {
  entry: './src/server/index.js',
  target: 'node',
  externals: [nodeExternals()],
  output: {
    path: path.resolve('dist'),
    filename: 'server.bundle.js'
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: 'babel-loader'
      }
    ]
  }
};

const clientConfig = {
  entry: './src/client/index.js',
  output: {
    path: path.resolve('public'),
    filename: 'bundle.js'
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: 'babel-loader'
      }
    ]
  }
};

module.exports = [serverConfig, clientConfig];

Updating the Server to Serve the Client Bundle

Update src/server/index.js to serve the client bundle:

const express = require('express');
const React = require('react');
const ReactDOMServer = require('react-dom/server');
const path = require('path');
const fs = require('fs');
const Home = require('../components/Home').default;

const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.static('public'));

app.get('*', (req, res) => {
  const content = ReactDOMServer.renderToString(React.createElement(Home));
  const template = fs.readFileSync(path.resolve('public/index.html'), 'utf8');
  const html = template.replace('<div id="root"></div>', `<div id="root">${content}</div>`);
  res.send(html);
});

app.listen(PORT, () => {
  console.log(`Server is listening on port ${PORT}`);
});

Creating the HTML Template

Create a public directory and inside it, create an index.html file with the following content:

<!DOCTYPE html>
<html>
  <head>
    <title>Server-Side Rendering with Node.js</title>
  </head>
  <body>
    <div id="root"></div>
    <script src="/bundle.js"></script>
  </body>
</html>

This file serves as the template for our server-rendered HTML.

Optimizing Server-Side Rendering

Code splitting allows you to split your code into various bundles which can then be loaded on demand or in parallel. This can significantly improve the performance of your application by reducing the initial load time.

Code Splitting

Code splitting allows you to split your code into various bundles which can then be loaded on demand or in parallel. This can significantly improve the performance of your application by reducing the initial load time.

Update webpack.config.js to enable code splitting:

const path = require('path');
const nodeExternals = require('webpack-node-externals');
const { CleanWebpackPlugin } = require('clean-webpack-plugin');

const serverConfig = {
  entry: './src/server/index.js',
  target: 'node',
  externals: [nodeExternals()],
  output: {
    path: path.resolve('dist'),
    filename: 'server.bundle.js'
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: 'babel-loader'
      }
    ]
  },
  plugins: [new CleanWebpackPlugin()]
};

const clientConfig = {
  entry: './src/client/index.js',
  output: {
    path: path.resolve('public'),
    filename: '[name].[contenthash].js'
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: 'babel-loader'
      }
    ]
  },
  optimization: {
    splitChunks: {
      chunks: 'all'
    }
  },
  plugins: [new CleanWebpackPlugin()]
};

module.exports = [serverConfig, clientConfig];

Adding a Router

To manage different routes in your application, you can use a routing library like react-router-dom. Install it using npm:

npm install react-router-dom

Update src/client/index.js to use the router:

import React from 'react';
import ReactDOM from 'react-dom';
import { BrowserRouter } from 'react-router-dom';
import App from '../components/App';

ReactDOM.hydrate(
  <BrowserRouter>
    <App />
  </BrowserRouter>,
  document.getElementById('root')
);

Update src/components/Home.js to include a basic router setup:

import React from 'react';
import { Route, Switch, Link } from 'react-router-dom';

const Home = () => (
  <div>
    <h1>Welcome to Server-Side Rendering with Node.js</h1>
    <p>This page is rendered on the server.</p>
    <nav>
      <Link to="/">Home</Link>
      <Link to="/about">About</Link>
    </nav>
  </div>
);

const About = () => (
  <div>
    <h1>About SSR</h1>
    <p>Server-Side Rendering (SSR) improves SEO and performance.</p>
  </div>
);

const App = () => (
  <Switch>
    <Route exact path="/" component={Home} />
    <Route path="/about" component={About} />
  </Switch>
);

export default App;

Update src/server/index.js to match the client router setup:

const express = require('express');
const React = require('react');
const ReactDOMServer = require('react-dom/server');
const path = require('path');
const fs = require('fs');
const { StaticRouter } = require('react-router-dom/server');
const App = require('../components/App').default;

const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.static('public'));

app.get('*', (req, res) => {
  const context = {};
  const content = ReactDOMServer.renderToString(
    <StaticRouter location={req.url} context={context}>
      <App />
    </StaticRouter>
  );

  const template = fs.readFileSync(path.resolve('public/index.html'), 'utf8');
  const html = template.replace('<div id="root"></div>', `<div id="root">${content}</div>`);
  res.send(html);
});

app.listen(PORT, () => {
  console.log(`Server is listening on port ${PORT}`);
});

Advanced Topics in Server-Side Rendering

Handling Data Fetching

To handle data fetching on the server, you can use a state management library like Redux. Install Redux and its related packages:

npm install redux react-redux redux-thunk

Set up a basic Redux store. Create a new file src/store.js:

import { createStore, applyMiddleware } from 'redux';
import thunk from 'redux-thunk';

const initialState = {};

const reducer = (state = initialState, action) => {
  switch (action.type) {
    default:
      return state;
  }
};

export const store = createStore(reducer, applyMiddleware(thunk));

Update src/client/index.js to use the Redux store:

import React from 'react';
import ReactDOM from 'react-dom';
import { Provider } from 'react-redux';
import { BrowserRouter } from 'react-router-dom';
import App from '../components/App';
import { store } from '../store';

ReactDOM.hydrate(
  <Provider store={store}>
    <BrowserRouter>
      <App />
    </BrowserRouter>
  </Provider>,
  document.getElementById('root')
);

Update src/server/index.js to provide the Redux store:

const express = require('express');
const React = require('react');
const ReactDOMServer = require('react-dom/server');
const path = require('path');
const fs = require('fs');
const { StaticRouter } = require('react-router-dom/server');
const { Provider } = require('react-redux');
const { store } = require('../store');
const App = require('../components/App').default;

const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.static('public'));

app.get('*', (req, res) => {
  const context = {};
  const content = ReactDOMServer.renderToString(
    <Provider store={store}>
      <StaticRouter location={req.url} context={context}>
        <App />
      </StaticRouter>
    </Provider>
  );

  const template = fs.readFileSync(path.resolve('public/index.html'), 'utf8');
  const html = template.replace('<div id="root"></div>', `<div id="root">${content}</div>`);
  res.send(html);
});

app.listen(PORT, () => {
  console.log(`Server is listening on port ${PORT}`);
});

Handling Authentication and Protected Routes

Setting Up Authentication

To handle authentication in your SSR setup, you can use libraries like passport for authentication strategies and express-session for session management. First, install the necessary packages:

npm install passport passport-local express-session

Configuring Passport

Create a new directory src/auth and within it, create a passportConfig.js file:

const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;

passport.use(new LocalStrategy(
  (username, password, done) => {
    // Dummy user validation
    if (username === 'user' && password === 'pass') {
      return done(null, { id: 1, username: 'user' });
    } else {
      return done(null, false, { message: 'Incorrect username or password.' });
    }
  }
));

passport.serializeUser((user, done) => {
  done(null, user.id);
});

passport.deserializeUser((id, done) => {
  // Dummy user retrieval
  done(null, { id: 1, username: 'user' });
});

Setting Up Session Management

In src/server/index.js, configure express-session and initialize Passport:

const express = require('express');
const session = require('express-session');
const passport = require('passport');
const React = require('react');
const ReactDOMServer = require('react-dom/server');
const path = require('path');
const fs = require('fs');
const { StaticRouter } = require('react-router-dom/server');
const { Provider } = require('react-redux');
const { store } = require('../store');
const App = require('../components/App').default;
require('../auth/passportConfig');

const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.static('public'));
app.use(express.urlencoded({ extended: true }));
app.use(session({ secret: 'secret', resave: false, saveUninitialized: false }));
app.use(passport.initialize());
app.use(passport.session());

app.post('/login', passport.authenticate('local', {
  successRedirect: '/',
  failureRedirect: '/login'
}));

app.get('*', (req, res) => {
  const context = {};
  const content = ReactDOMServer.renderToString(
    <Provider store={store}>
      <StaticRouter location={req.url} context={context}>
        <App />
      </StaticRouter>
    </Provider>
  );

  const template = fs.readFileSync(path.resolve('public/index.html'), 'utf8');
  const html = template.replace('<div id="root"></div>', `<div id="root">${content}</div>`);
  res.send(html);
});

app.listen(PORT, () => {
  console.log(`Server is listening on port ${PORT}`);
});

Creating Protected Routes

Update src/components/Home.js to include a login form and protected route:

import React from 'react';
import { Route, Switch, Link, Redirect } from 'react-router-dom';
import { useSelector } from 'react-redux';

const Home = () => (
  <div>
    <h1>Welcome to Server-Side Rendering with Node.js</h1>
    <p>This page is rendered on the server.</p>
    <nav>
      <Link to="/">Home</Link>
      <Link to="/about">About</Link>
      <Link to="/profile">Profile</Link>
    </nav>
  </div>
);

const About = () => (
  <div>
    <h1>About SSR</h1>
    <p>Server-Side Rendering (SSR) improves SEO and performance.</p>
  </div>
);

const Profile = () => {
  const isAuthenticated = useSelector(state => state.auth.isAuthenticated);
  return isAuthenticated ? (
    <div>
      <h1>Profile</h1>
      <p>Welcome to your profile.</p>
    </div>
  ) : (
    <Redirect to="/login" />
  );
};

const Login = () => (
  <div>
    <h1>Login</h1>
    <form action="/login" method="POST">
      <div>
        <label>Username: <input type="text" name="username" /></label>
      </div>
      <div>
        <label>Password: <input type="password" name="password" /></label>
      </div>
      <button type="submit">Login</button>
    </form>
  </div>
);

const App = () => (
  <Switch>
    <Route exact path="/" component={Home} />
    <Route path="/about" component={About} />
    <Route path="/profile" component={Profile} />
    <Route path="/login" component={Login} />
  </Switch>
);

export default App;

Managing Authentication State with Redux

Update src/store.js to handle authentication state:

import { createStore, applyMiddleware } from 'redux';
import thunk from 'redux-thunk';

const initialState = {
  auth: {
    isAuthenticated: false
  }
};

const reducer = (state = initialState, action) => {
  switch (action.type) {
    case 'LOGIN_SUCCESS':
      return {
        ...state,
        auth: {
          isAuthenticated: true
        }
      };
    case 'LOGOUT_SUCCESS':
      return {
        ...state,
        auth: {
          isAuthenticated: false
        }
      };
    default:
      return state;
  }
};

export const store = createStore(reducer, applyMiddleware(thunk));

Conclusion

Setting up server-side rendering with Node.js involves several steps, from configuring the server and client environment to handling data fetching and authentication. This guide covered the essentials to get you started, ensuring your application is optimized for SEO, performance, and a seamless user experience. By following these steps, you can leverage the full potential of server-side rendering to build fast, scalable, and user-friendly web applications.

Feel free to experiment and expand upon this setup to meet the specific needs of your project. Whether you’re building a simple website or a complex web application, server-side rendering with Node.js provides a robust foundation for delivering high-performance, SEO-friendly content.

Read Next: