Real-Time Basics

npm install ws
npm install -D @types/ws

Use WebSocket when:
- Client sends messages frequently (chat, gaming, collaboration)
- Latency must be < 50ms round-trip
- Bidirectional binary data (audio, file chunks)
- Connection state matters (presence, typing indicators)

Use SSE when:
- Server pushes updates; client only sends via normal HTTP
- Live feeds (stock prices, sports scores, logs)
- Notification streams
- You want automatic browser reconnection

// SSE response headers
res.writeHead(200, {
  "Content-Type": "text/event-stream",
  "Cache-Control": "no-cache",
  Connection: "keep-alive",
});
res.write("data: {\"price\": 142.50}\n\n");

Use long-polling when:
- Infrastructure blocks WebSocket (rare corporate proxies)
- Extremely simple notification need
- Fallback for Socket.IO (handled automatically)

WebSocket lifecycle:
1. Client sends HTTP Upgrade request
2. Server responds 101 Switching Protocols
3. Persistent TCP connection established
4. Frames exchanged bidirectionally
5. Either side sends close frame
6. Connection terminated
 
SSE lifecycle:
1. Client opens HTTP GET (EventSource)
2. Server streams text/event-stream
3. Connection stays open
4. Server sends data: lines
5. On disconnect, browser auto-reconnects

// WebSocket: validate during upgrade
server.on("upgrade", (req, socket, head) => {
  const token = new URL(req.url!, "http://localhost").searchParams.get("token");
  if (!

import express from "express";
import { createServer } from "node:http";
import { WebSocketServer } from "ws";
 
const app = express();
const server = createServer(app);
const wss = new

import Fastify from "fastify";
 
const app = Fastify();
 
app.get("/events", async (req, reply) => {
  reply.raw.writeHead(200, {
    "Content-Type": 

Before 1000 concurrent connections, plan for:
- Sticky sessions (load balancer affinity)
- Redis pub/sub for cross-instance messaging
- Connection limits per instance
- Heartbeat/ping to detect dead connections
- Graceful shutdown (notify clients, close connections)