Why real-time matters in Express - Performance Evidence

Performance: Why real-time matters

HIGH IMPACT

Real-time affects how quickly users see updates and interact with the app, impacting responsiveness and user experience.

Delivering live updates to users in a web app

Express

const http = require('http');
const express = require('express');
const { Server } = require('socket.io');
const app = express();
const server = http.createServer(app);
const io = new Server(server);
io.on('connection', (socket) => {
  // Push updates instantly
  socket.emit('update', { data: 'new data' });
});
server.listen(3000);

Using WebSockets pushes updates instantly without repeated requests, reducing latency and server load.

📈 Performance GainSingle persistent connection per client, reducing network overhead and improving INP significantly.

Delivering live updates to users in a web app

Express

app.get('/updates', (req, res) => {
  // Endpoint for client-side polling every 5 seconds
  res.json({ data: 'new data' });
});

Polling causes repeated HTTP requests, increasing server load and latency, leading to slower updates and higher bandwidth use.

📉 Performance CostTriggers multiple network requests per user, increasing server CPU and bandwidth usage, causing slower INP.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Polling HTTP requests every 5 seconds	Multiple repeated DOM updates	Multiple reflows per update	High paint cost due to frequent updates	[X] Bad
WebSocket push updates	Single DOM update per event	Minimal reflows triggered	Lower paint cost with targeted updates	[OK] Good

Rendering Pipeline

Real-time data pushes bypass repeated HTTP requests, reducing delays before the browser can update the UI and improving interaction responsiveness.

→Network

→JavaScript Execution

→Paint

→Composite

⚠️ BottleneckNetwork latency and repeated HTTP request overhead

Core Web Vital Affected

INP

Real-time affects how quickly users see updates and interact with the app, impacting responsiveness and user experience.

Optimization Tips

1Avoid frequent polling; use persistent connections like WebSockets.

2Push updates only when data changes to reduce unnecessary DOM updates.

3Monitor network and scripting time to ensure real-time features do not block rendering.

Performance Quiz - 3 Questions

Which real-time pattern reduces server load and improves interaction responsiveness?

A Reloading the entire page on update

B Polling the server every second

C Using WebSockets to push updates

D Sending updates via email

DevTools: Performance

How to check: Record a session while interacting with real-time features; look for network requests and scripting time.

What to look for: Frequent network requests and scripting spikes indicate polling; steady low network activity with event-driven updates indicates good real-time performance.

Practice

1. Why is real-time communication important in web applications like chat or live games?

easy

A. It makes the website load faster initially.

B. It allows instant updates between users and the server.

C. It reduces the size of the application code.

D. It stores data permanently on the server.

Solution

1. Step 1: Understand real-time communication purpose

   Real-time means users get updates immediately without refreshing the page.

2. Step 2: Identify why instant updates matter

   Chat and live games need instant data exchange to feel interactive and responsive.

3. Final Answer:

   It allows instant updates between users and the server. -> Option B

4. Quick Check:

   Real-time = instant updates [OK]

Hint: Real-time means no waiting for updates [OK]

Common Mistakes:

• Confusing real-time with faster page load
• Thinking real-time reduces code size
• Assuming real-time stores data permanently

2. Which code snippet correctly sets up a basic Express server with Socket.io for real-time communication?

easy

A. const app = express(); const server = http.createServer(); const io = socket.io(server); server.listen(3000);

B. const app = express(); const io = require('socket.io')(app); app.listen(3000);

C. const app = express(); const server = require('http').createServer(app); const io = require('socket.io')(server); server.listen(3000);

D. const app = express(); const server = require('http').createServer(app); const io = socket(server); server.listen(3000);

Solution

1. Step 1: Check correct imports and server creation

   const app = express(); const server = require('http').createServer(app); const io = require('socket.io')(server); server.listen(3000); uses require('http').createServer(app) which is correct to create a server for Express.

2. Step 2: Verify Socket.io initialization

   const app = express(); const server = require('http').createServer(app); const io = require('socket.io')(server); server.listen(3000); correctly passes the server to Socket.io with require('socket.io')(server).

3. Final Answer:

   const app = express(); const server = require('http').createServer(app); const io = require('socket.io')(server); server.listen(3000); -> Option C

4. Quick Check:

   Express + HTTP server + Socket.io = const app = express(); const server = require('http').createServer(app); const io = require('socket.io')(server); server.listen(3000); [OK]

Hint: Socket.io needs HTTP server, not just app [OK]

Common Mistakes:

• Passing app directly to Socket.io instead of server
• Missing require('http') for server creation
• Using undefined variables like http or socket

3. Given this Express and Socket.io code snippet, what will be logged when a client connects?

const express = require('express');
const app = express();
const server = require('http').createServer(app);
const io = require('socket.io')(server);

io.on('connection', (socket) => {
  console.log('User connected');
  socket.on('message', (msg) => {
    console.log('Message:', msg);
  });
});

server.listen(3000);

medium

A. User connected

B. Message: User connected

C. Error: socket.on is not a function

D. No output until a message is sent

Solution

1. Step 1: Analyze connection event handler

   When a client connects, the 'connection' event triggers and logs 'User connected'.

2. Step 2: Understand message event timing

   The 'message' event logs only when a message is received, so no message means no log.

3. Final Answer:

   User connected -> Option A

4. Quick Check:

   Connection logs 'User connected' immediately [OK]

Hint: Connection logs immediately; messages log later [OK]

Common Mistakes:

• Thinking message logs on connection
• Expecting error from socket.on usage
• Assuming no output without messages

4. Identify the error in this Express and Socket.io setup:

const express = require('express');
const app = express();
const io = require('socket.io')(app);

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

app.listen(3000);

medium

A. The 'connection' event should be 'connect'.

B. Missing import for 'http' module.

C. app.listen should be replaced with server.listen.

D. Socket.io should be attached to an HTTP server, not the Express app.

Solution

1. Step 1: Check how Socket.io is initialized

   Socket.io must be attached to an HTTP server, not directly to the Express app.

2. Step 2: Confirm correct server setup

   Express app needs an HTTP server created with require('http').createServer(app) to pass to Socket.io.

3. Final Answer:

   Socket.io should be attached to an HTTP server, not the Express app. -> Option D

4. Quick Check:

   Socket.io needs HTTP server, not app [OK]

Hint: Socket.io requires HTTP server, not just Express app [OK]

Common Mistakes:

• Using 'connect' event instead of 'connection'
• Calling app.listen instead of server.listen without server
• Forgetting to create HTTP server

5. You want to build a real-time collaborative drawing app using Express and Socket.io. Which approach best ensures all users see updates instantly and correctly?

hard

A. Use Socket.io to emit drawing data to all connected clients except the sender.

B. Use HTTP GET requests to fetch the latest drawing data every second.

C. Store drawing data only on the client side and sync on page reload.

D. Send drawing data via email to all users after each stroke.

Solution

1. Step 1: Understand real-time data sharing needs

   Collaborative drawing requires instant updates to all users as changes happen.

2. Step 2: Evaluate communication methods

   Socket.io can emit data to all clients except sender to update their views immediately.

3. Step 3: Rule out inefficient or delayed methods

   HTTP polling or email delays updates and breaks real-time experience.

4. Final Answer:

   Use Socket.io to emit drawing data to all connected clients except the sender. -> Option A

5. Quick Check:

   Real-time = Socket.io emit to all clients [OK]

Hint: Emit updates instantly with Socket.io to all clients [OK]

Common Mistakes:

• Using slow HTTP polling instead of real-time sockets
• Relying on client reloads for sync
• Ignoring real-time update needs