Real-Time Web Applications Course

Lesson 1 • The Request-Response Limitation

Examines why traditional HTTP polling fails for live data. Connects latency and bandwidth waste to the need for persistent connections.

Lesson 2 • Real-Time Use Case Taxonomy

Categorizes live chat, dashboards, gaming, and collaboration tools by their communication requirements. Grounds abstract concepts in industry scenarios.

Lesson 3 • Real-Time Communication Models

Contrasts push, pull, and bidirectional models. Provides a decision framework students apply throughout the course.

Lesson 1 • The WebSocket Handshake

Details the HTTP upgrade negotiation that establishes a WebSocket connection. Students trace headers and status codes in browser dev tools.

Lesson 2 • Frame Structure and Data Types

Explains opcodes, masking, and payload length encoding in WebSocket frames. Students parse binary and text frames manually.

Lesson 3 • Security Considerations for WebSocket

Addresses origin validation, WSS encryption, and cross-site WebSocket hijacking. Students apply defensive headers and token-based auth.

Lesson 4 • Ping, Pong, and Keep-Alive

Explains heartbeat frames for detecting stale connections. Students configure server-side ping intervals and handle pong timeouts.

Lesson 1 • HTTP Chunked Transfer Streaming

Explains chunked encoding as a lower-level streaming primitive. Students compare it to SSE and implement a streaming JSON endpoint.

Lesson 2 • Server-Side SSE Implementation

Demonstrates keeping HTTP responses open and flushing events. Students implement SSE endpoints in a Node.js server.

Lesson 3 • SSE Limitations and Workarounds

Identifies browser connection limits, proxy buffering, and lack of binary support. Students apply workarounds including multiplexing and base64 encoding.

Lesson 4 • SSE Protocol Mechanics

Explains the text/event-stream content type, event fields, and browser EventSource API. Connects SSE simplicity to HTTP infrastructure compatibility.

Lesson 1 • Graceful Shutdown and Drain

Implements signal handling to close connections cleanly before process exit. Students prevent message loss during rolling deployments.

Lesson 2 • Message Serialization and Framing

Compares JSON, MessagePack, and Protocol Buffers for real-time payloads. Students benchmark serialization overhead and choose formats by use case.

Lesson 3 • Event-Loop Architecture

Explains non-blocking I/O and the event loop as the foundation for concurrency. Students profile event-loop lag under simulated load.

Lesson 4 • Connection Registry and Routing

Designs an in-memory registry mapping connection IDs to sockets. Students implement targeted message delivery and broadcast patterns.

Lesson 1 • Delta Synchronization

Sends only changed fields instead of full state snapshots to reduce bandwidth. Students implement a diff-patch cycle for live document sync.

Lesson 2 • Presence and Awareness Data

Tracks which users are online, typing, or viewing a resource. Students build a presence system with heartbeat-based expiry.

Lesson 3 • Optimistic Updates and Rollback

Applies optimistic UI updates before server confirmation to reduce perceived latency. Students implement rollback on server rejection.

Lesson 4 • Client-Server State Models

Contrasts authoritative server, client-authoritative, and hybrid state models. Students map each model to appropriate real-time use cases.

Lesson 1 • Input Validation and Sanitization

Validates and sanitizes all incoming real-time messages to prevent injection attacks. Students apply schema validation to WebSocket message payloads.

Lesson 2 • Authentication at Connection Time

Validates identity during the WebSocket handshake or SSE request. Students implement token-in-query-string and cookie-based auth flows.

Lesson 3 • Authorization for Channels and Rooms

Enforces per-room and per-channel access control after authentication. Students build a permission middleware for join and subscribe operations.

Lesson 4 • Rate Limiting and Abuse Prevention

Applies per-connection and per-user message rate limits to prevent flooding. Students implement token-bucket rate limiting on the server.

Lesson 1 • Pub/Sub Broker Integration

Integrates a pub/sub broker to relay messages across server instances. Students connect a server cluster through a shared message bus.

Lesson 2 • The Multi-Process Scaling Problem

Explains why in-memory state breaks when connections span multiple server instances. Students reproduce the cross-process message loss bug.

Lesson 3 • Backpressure and Flow Control

Prevents fast producers from overwhelming slow consumers using backpressure signals. Students implement send-queue limits and client-side flow control.

Lesson 4 • Horizontal Scaling Patterns

Applies sharding, consistent hashing, and connection migration for large-scale deployments. Students design a shard-aware routing layer.

Lesson 1 • Integration and End-to-End Testing

Spins up real server instances and drives them with WebSocket clients in tests. Students verify room join, message delivery, and disconnect behavior.

Lesson 2 • Unit Testing Real-Time Logic

Isolates and tests message handlers, state reducers, and routing logic without live connections. Students mock WebSocket objects in test suites.

Lesson 3 • Distributed Tracing for Message Flows

Propagates trace context through WebSocket messages to correlate client events with server processing. Students visualize end-to-end message latency.

Lesson 4 • Load Testing Real-Time Servers

Simulates thousands of concurrent WebSocket connections to find throughput limits. Students interpret latency percentiles and identify bottlenecks.