Get Started
Log In
Sign Up
Log In

Building Real-Time Applications with Socket.IO in the MEAN Stack

building real time applications with in the mean stack

Table of content

If you’re a developer working with the MEAN (MongoDB, Express.js, Angular, Node.js) stack, you’re probably already aware of its power for creating dynamic web applications. But what if you want to take your MEAN application to the next level and add real-time functionality? That’s where Socket.IO comes into play. In this blog post, we’ll explore how to build real-time applications with Socket.IO in the MEAN stack, step by step.

Understanding Real-Time Applications

Before diving into Socket.IO, let’s first understand what real-time applications are and why they’re essential. Real-time applications are those that require immediate data updates and interactions between users and the server. Think of chat applications, online gaming, collaborative tools, or live dashboards – these are all examples of real-time applications.

Traditional web applications follow a request-response model. The client sends a request to the server, and the server processes it and sends back a response. This works well for many scenarios but falls short when you need instant updates without the client having to refresh the page continuously.

Socket.IO solves this problem by enabling real-time, bidirectional communication between clients (browsers) and the server. It’s built on top of WebSockets, a protocol that allows full-duplex communication channels over a single TCP connection. Socket.IO abstracts away the complexities of dealing with raw WebSockets, making it easier for developers to implement real-time features.

Setting Up Your MEAN Stack Environment

Before we get into Socket.IO, make sure you have a basic MEAN stack environment set up. If you haven’t done that yet, here’s a brief overview:

  • MongoDB: As the database for storing your application’s data.
  • Express.js: As the backend framework for building APIs and handling HTTP requests.
  • Angular: As the frontend framework for creating a dynamic user interface.
  • Node.js: As the runtime environment for running your server-side code.
  • You can use tools like Angular CLI and Express Generator to scaffold your Angular and Express projects, respectively.

Installing Socket.IO

Now that you have your MEAN stack environment ready, let’s add Socket.IO to the mix. Open your terminal and navigate to your project’s root directory. Here are the steps to install Socket.IO:

Install the Socket.IO server library:

npm install

Install the Socket.IO client library in your Angular application:

ng add ngx-socket-io

This command installs the necessary client-side dependencies and configures your Angular app to work with Socket.IO.

Creating a Real-Time Chat Application

To demonstrate the power of Socket.IO in the MEAN stack, let’s build a simple real-time chat application. We’ll start with the backend using Node.js and Express, and then we’ll integrate it with an Angular frontend.

Backend Setup

Create a new file named server.js:

const express = require('express');
const http = require('http');
const socketIo = require('');
const app = express();
const server = http.createServer(app);
const io = socketIo(server);
// Your Express app configuration here
// Socket.IO server logic here
const port = process.env.PORT || 3000;
server.listen(port, () => {
console.log(`Server is running on port ${port}`);

Configure Socket.IO:

io.on('connection', (socket) => {
console.log('A user connected');
// Handle incoming chat messages
socket.on('message', (message) => {
io.emit('message', message); // Broadcast to all clients
// Handle user disconnection
socket.on('disconnect', () => {
console.log('A user disconnected');

Integrate Socket.IO with Express:

const cors = require('cors'); // Add this line
app.use(cors()); // Add this line
// Other Express middleware and routes

Frontend Integration

Now that the backend is set up to handle real-time communication with Socket.IO, let’s create the Angular frontend.

Generate a new Angular component for the chat:

ng generate component chat

Update the chat.component.ts file:

import { Component, OnInit } from '@angular/core';
import { Socket } from 'ngx-socket-io'; // Import Socket from ngx-socket-io
selector: 'app-chat',
templateUrl: './chat.component.html',
styleUrls: ['./chat.component.css'],
export class ChatComponent implements OnInit {
message: string = '';
messages: string[] = [];
constructor(private socket: Socket) {} // Inject Socket service
ngOnInit(): void {
// Listen for incoming messages and add them to the messages array
this.socket.on('message', (message: string) => {
sendMessage(): void {
if (this.message.trim() !== '') {
// Send the message to the server
this.socket.emit('message', this.message);
this.message = '';

Update the chat.component.html file:

<div class="chat-container">
<div class="chat-messages">
<div *ngFor="let msg of messages" class="message">{{ msg }}</div>
<div class="chat-input">
placeholder="Type your message..."
<button (click)="sendMessage()">Send</button>

Add the FormsModule to your app.module.ts:

import { FormsModule } from '@angular/forms'; // Import FormsModule
declarations: [/* ... */],
imports: [/* ... */, FormsModule], // Add FormsModule here
providers: [],
bootstrap: [AppComponent],
export class AppModule {}

Styling Your Chat Application

You can style your chat application using CSS or a UI framework like Bootstrap. For simplicity, let’s add some basic CSS styles to chat.component.css:

.chat-container {
display: flex;
flex-direction: column;
align-items: center;
padding: 20px;
.chat-messages {
max-height: 400px;
overflow-y: auto;
border: 1px solid #ccc;
padding: 10px;
width: 400px;
.message {
margin-bottom: 10px;
padding: 5px;
background-color: #f0f0f0;
border-radius: 5px;
.chat-input {
display: flex;
width: 400px;
margin-top: 10px;
input[type="text"] {
flex: 1;
padding: 5px;
border: 1px solid #ccc;
border-radius: 5px;
button {
margin-left: 10px;
padding: 5px 10px;
background-color: #007bff;
color: #fff;
border: none;
border-radius: 5px;
cursor: pointer;

Testing Your Real-Time Chat Application

With the backend and frontend in place, it’s time to test your real-time chat application. Start your server by running node server.js in your backend directory. Then, serve your Angular app using ng serve in your frontend directory.

Open multiple browser windows or tabs and access the chat application. You’ll see that messages sent from one client instantly appear on all other connected clients, demonstrating the real-time capabilities of Socket.IO.


Socket.IO is a powerful tool for adding real-time functionality to your MEAN stack applications. In this blog post, we’ve covered the basics of setting up a real-time chat application using Socket.IO in the MEAN stack. You can expand on this foundation to build more complex real-time features like notifications, live updates, or collaborative tools.

Remember that real-time applications come with their own challenges, such as handling user authentication, managing room-based communication, and optimizing performance. But with Socket.IO and the MEAN stack, you have a solid foundation to create engaging and interactive real-time web applications.

So, go ahead and experiment with Socket.IO in your MEAN projects, and unlock the world of real-time possibilities for your web applications.

Table of content