Designing Stateless Resource Handlers

In this lesson, you’ll learn how to decouple your server process identity from client session data to ensure your application can scale horizontally without friction.

The Problem with State

When a Node.js server stores user session data—like a shopping cart or authentication status—directly in its local memory, that server becomes "stateful." If you have three servers behind a load balancer and a user connects to Server A, their session lives only on Server A. If the load balancer sends their next request to Server B, the user is suddenly "logged out" or loses their progress because Server B doesn't know who they are. This limits your ability to add more servers to handle traffic spikes.

Designing Stateless Handlers

A stateless resource handler treats every incoming HTTP request as an independent, self-contained event. It does not rely on local process memory or persistent connections to track the client. Instead, it offloads session state to an external, shared location—like a distributed cache (e.g., Redis) or relies on cryptographically signed tokens (e.g., JWTs) sent by the client.

By decoupling the process from the data, any available server in your cluster can handle any incoming request.

Consider this simple pattern for a stateless check:

// Instead of checking a local 'sessions' object:
// if (sessions[req.headers.cookie]) { ... }

// A stateless handler verifies the request independently:
function handleRequest(req, res) {
  const token = req.headers.authorization;
  
  // Verify token signature without querying local memory
  const user = verifyToken(token); 
  
  if (!user) {
    return res.status(401).send('Unauthorized');
  }
  
  // Process resource using only data provided in the request
  processResource(req.body, user);
}

Why This Scales

When your handlers are stateless, the server process becomes a "disposable" unit. If Server A reaches its memory limit or crashes, your load balancer simply routes traffic to Server C. Because the session data is stored externally or passed in the request itself, the user experience remains seamless, and your infrastructure can scale horizontally with ease.

Key Takeaway: By offloading session state to external stores or request tokens, you transform your servers into interchangeable units that can scale infinitely across your infrastructure.