Frontend System Design · Lesson 41 of 86 · 3 min
Real-Time: Polling, SSE and WebSockets
In an interview, you'll be asked how to get real-time updates. This is how you choose the right tool and defend your choice with the right trade-offs.
Start with the baseline: Polling
Polling is the simplest way to get fresh data. The client asks the server for updates on a fixed interval, like every 5 seconds. It's just a setInterval that calls fetch.
Use it when "real-time" is a loose requirement and simplicity is key. Think of a dashboard that only needs to refresh every few minutes, or a background check for new notifications. It's inefficient but it's predictable and works everywhere.
The trap: Candidates either forget polling exists or dismiss it too quickly. Acknowledging it as a valid, simple option before jumping to WebSockets shows you value pragmatism. Don't use it for anything requiring updates faster than a few seconds; the network overhead and server load become liabilities.
Long polling is a small optimization. The client makes a request, but the server holds the connection open, only responding when it has new data or a timeout occurs. Once the client gets a response, it immediately opens a new connection. This reduces latency compared to standard polling, as updates arrive as soon as they're available on the server. It's a stepping stone, but modern solutions are usually better.
For server-to-client push: Server-Sent Events (SSE)
SSE is a one-way street: the server pushes data to the client over a single, long-lived HTTP connection. The client just listens.
This is your go-to for features like live news feeds, stock tickers, or activity streams where the client is a passive receiver. It's simpler than WebSockets, built on standard HTTP, and has a clean browser API (EventSource) with automatic reconnection.
In an interview, position SSE as the default choice for one-way data streams. It shows you know a modern, efficient alternative to WebSockets when full-duplex communication is overkill. Mentioning its built-in reconnection support is a key point.
The main limitation is that it's unidirectional. To send data to the server, the client must make a separate fetch request.
function connectToEventStream(url) {
// EventSource is the native browser API for SSE.
const source = new EventSource(url);
source.onopen = () => {
console.log("SSE connection established.");
};
// 'onmessage' is the default handler for events without a specific name.
source.onmessage = (event) => {
const data = JSON.parse(event.data);
console.log("Received generic event:", data);
// Update your UI here.
};
// You can listen for named events from the server.
source.addEventListener('user_update', (event) => {
const userData = JSON.parse(event.data);
console.log("Received user update:", userData);
});
source.onerror = (err) => {
// The browser will automatically try to reconnect.
// You might log this to a monitoring service.
console.error("EventSource failed:", err);
};
// Return a function to allow cleanup.
return () => {
source.close();
console.log("SSE connection closed.");
};
}
// const closeConnection = connectToEventStream('/api/updates');
// To stop listening: closeConnection();
For two-way conversations: WebSockets
WebSockets provide a true two-way, full-duplex communication channel over a single TCP connection. After an initial HTTP "upgrade" handshake, both client and server can send messages to each other at any time with minimal overhead.
This is the right tool for complex, interactive features: chat applications, collaborative document editing, or multiplayer games. The low latency and bidirectional nature are essential for these use cases.
The trade-off is complexity. You need a dedicated WebSocket server or a backend that supports the protocol. You are also responsible for implementing your own reconnection logic, message formats (sub-protocols), and handling potential firewall or proxy issues that might block the ws:// or wss:// protocols.
How to choose in an interview
Your decision process should be clear and based on requirements. Start with the simplest option that works and justify why you need to move to a more complex one.
-
Is the data flow one-way or two-way?
- One-way (server-to-client): SSE is the strong default. It's simpler and more efficient than using WebSockets for a one-way stream.
- Two-way: WebSockets are necessary.
-
What are the latency requirements?
- Low (minutes): Simple polling is fine.
- Medium (seconds): Long polling is an option, but SSE is often better.
- Very low (sub-second): WebSockets are the best choice due to minimal message overhead.
-
What is the update frequency?
- Infrequent: Polling is acceptable.
- Frequent or bursty: SSE or WebSockets are far more efficient. They avoid the overhead of establishing a new HTTP connection for every update.
The diagram below contrasts the communication flow for SSE and WebSockets. Use it to visualize the difference between a one-way event stream and a full-duplex message exchange.
Try it
Build a simple "like" button component that displays a counter. First, implement the counter update using short polling every 3 seconds. Then, refactor it to use Server-Sent Events from a mock server. Notice the difference in network traffic and how immediately the UI updates with SSE.
Next: Real-Time Use Cases: Chat, Alerts, Live Data
Lock it in — apply this lesson under interview conditions.