Power up Your Web App's Responsiveness: Building Real-time Features with Socket.IO and React

Are you tired of web applications that feel slow and unresponsive? If you've ever used a chat application or real-time update in an application, you know it's a game-changer. Users expect real-time updates and seamless communication in modern web applications. In this tutorial, we'll show you how to build and integrate real-time features using Socket.IO and React. You'll learn the power of real-time web applications and how to take your web development skills to the next level.

What Are Real-time Web Applications?

A real-time web application is one that continuously updates and communicates with the server in real-time. Unlike traditional web applications that use the HTTP protocol, real-time web applications use WebSockets: a protocol that enables full-duplex communication over a single, long-lived connection. WebSockets allow you to send and receive data in real-time, making it ideal for building chat applications, collaborative editing, or real-time updates in your application.

Building a Chat Application with Socket.IO and React

In this tutorial, we'll build a real-time chat application that demonstrates the power of Socket.IO and React. We'll focus on the server-side first and then build out the client-side.

Server-side Setup

To get started with Socket.IO, you'll need to install it as a dependency. In your terminal, navigate to your project directory and type:

npm install socket.io

Once you've installed Socket.IO, you'll need to create a server that listens to incoming connections. Create a new file called server.js and add the following code:

const io = require('socket.io')(server);

io.on('connection', (socket) => {
  console.log(`Client connected: ${socket.id}`);

  socket.on('disconnect', () => {
    console.log(`Client disconnected: ${socket.id}`);

Here, we've created a new Socket.IO server and set it up to listen on the server object. We've also added an event listener for the connection event. Whenever a client connects to the server, a new socket object is created that represents the connection. We've logged out the socket ID to the console for debugging purposes.

The server can now communicate with connected clients through the socket. Let's create an event that handles incoming chat messages. Add the following code to your server:

socket.on('chat message', (msg) => {
  console.log(`Message received: ${msg}`);
  io.emit('chat message', msg);

This event listener handles incoming chat messages. Whenever a client sends a chat message, the server logs it to the console and then emits the same message to all connected clients through the io object. This sends the message to all connected clients, including the sender.

Client-side Setup

Now that we have our server set up, let's build the client-side. Start by creating a new React project and installing the socket.io-client dependency:

npx create-react-app chat-app
cd chat-app
npm install socket.io-client

Then, open up your src/index.js file and add the following code:

import React from 'react';
import ReactDOM from 'react-dom';
import io from 'socket.io-client';

const socket = io('http://localhost:3001');

class ChatApp extends React.Component {
  constructor(props) {
    this.state = { messages: [], value: '' };

    this.handleChange = this.handleChange.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);

  componentDidMount() {
    socket.on('chat message', (msg) => {
      this.setState({ messages: [...this.state.messages, msg] });

  handleChange(event) {
    this.setState({ value: event.target.value });

  handleSubmit(event) {
    socket.emit('chat message', this.state.value);
    this.setState({ value: '' });

  render() {
    return (
          {this.state.messages.map((message, idx) => (
            <li key={idx}>{message}</li>
        <form onSubmit={this.handleSubmit}>
          <input type="text" value={this.state.value} onChange={this.handleChange} />

    <ChatApp />

This code sets up the Socket.IO client and creates a new React component called ChatApp. In the constructor, we set the initial state to an empty messages array and a blank value. We also bind the handleChange and handleSubmit functions to the component.

The componentDidMount function sets up an event listener for incoming chat messages. Whenever a message is received, we update the component state with the new message. The handleChange function updates the component state whenever the input field changes, and the handleSubmit function sends the chat message to the server and clears the input field.

The render function displays the list of messages and the input field for sending new messages. Whenever the component state changes, the render function is called again, updating the displayed messages.

Testing the Chat Application

Now that we have both the server-side and client-side set up, let's start the application and test it out. In your terminal, start the server with:

node server.js

Then, in a separate terminal window, start the React application with:

npm start

The chat application should open in your browser automatically. Open up a new tab or browser window and navigate to the same URL to simulate two different clients. Try sending messages between them to see the real-time updates in action!


You've now seen how to build real-time web applications using Socket.IO and React. With WebSocket technology, you can create applications that are both seamless and responsive for your users. We hope this tutorial has provided you insight into the power of Socket.IO and inspired you to implement real-time features in your own web applications. Happy coding!