Server-Sent Events alternative in Flask - Performance & Optimization

Performance: Server-Sent Events alternative

MEDIUM IMPACT

This concept affects how fast the page can receive live updates and how much CPU and network resources are used during continuous data streaming.

Sending real-time updates from server to client

Flask

from flask import Flask, render_template
from flask_socketio import SocketIO, emit
import eventlet
import time

eventlet.monkey_patch()

app = Flask(__name__)
socketio = SocketIO(app)

def send_time():
    while True:
        socketio.emit('time_update', {'time': time.ctime()})
        socketio.sleep(1)
socketio.start_background_task(send_time)

@app.route('/')
def index():
    return render_template('index.html')

if __name__ == '__main__':
    socketio.run(app)

WebSockets use a single persistent connection that allows two-way communication with less overhead and better scalability for many clients.

📈 Performance GainReduces network overhead and CPU usage per client; improves responsiveness and scales better

Sending real-time updates from server to client

Flask

from flask import Flask, Response
import time

app = Flask(__name__)

def event_stream():
    while True:
        yield f'data: The time is {time.ctime()}\n\n'
        time.sleep(1)

@app.route('/stream')
def stream():
    return Response(event_stream(), mimetype='text/event-stream')

Server-Sent Events keep an HTTP connection open and send updates as text streams, which can cause higher CPU usage and more network overhead for many clients.

📉 Performance CostKeeps one HTTP connection per client open, triggering continuous network activity and moderate CPU load

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Server-Sent Events	Low (stream updates as text)	Low (updates usually don't change layout)	Low to Medium (depends on update frequency)	[!] OK
WebSockets	Low (event-driven updates)	Low	Low	[OK] Good

Rendering Pipeline

Server-Sent Events keep an HTTP connection open and stream text data, causing repeated network activity and triggering browser updates. WebSockets establish a persistent, full-duplex connection that reduces repeated HTTP overhead and allows faster message delivery.

→Network

→JavaScript Execution

→Paint

→Composite

⚠️ BottleneckNetwork overhead and JavaScript event handling

Core Web Vital Affected

INP

This concept affects how fast the page can receive live updates and how much CPU and network resources are used during continuous data streaming.

Optimization Tips

1Use WebSockets for two-way real-time communication to reduce network overhead.

2Avoid Server-Sent Events if you need bidirectional communication or many clients.

3Monitor open connections in DevTools Network tab to check streaming performance.

Performance Quiz - 3 Questions

Which method generally uses less network overhead for real-time updates?

A Server-Sent Events with HTTP streaming

B WebSockets with a persistent connection

C Polling with repeated HTTP requests

D Loading updates via full page reloads

DevTools: Network

How to check: Open DevTools, go to Network tab, filter by 'EventStream' or 'WebSocket', observe the open connections and data frames sent over time.

What to look for: Look for continuous HTTP streaming requests for SSE and persistent WebSocket frames; fewer headers and smaller frames indicate better performance.

Practice

1. What is a common alternative to Server-Sent Events (SSE) for real-time communication in Flask applications?

easy

A. Static HTML pages

B. Regular HTTP GET requests

C. WebSockets using Flask-SocketIO

D. Email notifications

Solution

1. Step 1: Understand SSE purpose

   Server-Sent Events send updates one-way from server to browser for real-time data.

2. Step 2: Identify alternative for two-way communication

   WebSockets allow two-way real-time communication and Flask-SocketIO simplifies their use in Flask.

3. Final Answer:

   WebSockets using Flask-SocketIO -> Option C

4. Quick Check:

   Real-time two-way communication = WebSockets [OK]

Hint: WebSockets enable two-way real-time updates, unlike SSE [OK]

Common Mistakes:

• Confusing SSE with regular HTTP requests
• Thinking static pages can update in real-time
• Assuming email is real-time communication

2. Which of the following is the correct way to import Flask-SocketIO in a Flask app?

easy

A. from flask_socketio import SocketIO

B. import flask_socketio.SocketIO

C. from flask import SocketIO

D. import SocketIO from flask_socketio

Solution

1. Step 1: Recall correct import syntax in Python

   Python uses 'from module import class' to import specific classes.

2. Step 2: Match Flask-SocketIO import pattern

   The correct import is 'from flask_socketio import SocketIO' to get the SocketIO class.

3. Final Answer:

   from flask_socketio import SocketIO -> Option A

4. Quick Check:

   Correct Python import syntax = from flask_socketio import SocketIO [OK]

Hint: Use 'from module import class' for specific imports in Python [OK]

Common Mistakes:

• Using JavaScript import syntax in Python
• Importing SocketIO from flask instead of flask_socketio
• Incorrect module or class names

3. Given this Flask-SocketIO code snippet, what will the client receive when the server emits 'message' event?

from flask_socketio import SocketIO, emit

socketio = SocketIO(app)

@socketio.on('connect')
def handle_connect():
    emit('message', {'data': 'Welcome!'})

medium

A. No message is sent on connect

B. A plain text message 'Welcome!'

C. An error because emit needs a string message

D. A JSON object with {'data': 'Welcome!'}

Solution

1. Step 1: Understand the emit function usage

   emit sends an event with a dictionary payload as JSON to the client.

2. Step 2: Analyze the event and data sent on connect

   On 'connect', the server emits 'message' event with {'data': 'Welcome!'} dictionary.

3. Final Answer:

   A JSON object with {'data': 'Welcome!'} -> Option D

4. Quick Check:

   emit sends JSON data = A JSON object with {'data': 'Welcome!'} [OK]

Hint: emit sends JSON-like dict, not plain text [OK]

Common Mistakes:

• Thinking emit sends plain text only
• Assuming emit requires string, not dict
• Believing no message is sent on connect

4. Identify the error in this Flask-SocketIO server code:

from flask_socketio import SocketIO

socketio = SocketIO(app)

@socketio.on('message')
def handle_message(data):
    print('Received:', data)

socketio.run(app)

medium

A. Function handle_message missing return statement

B. Missing import of Flask app

C. No event handler for 'connect'

D. Using socketio.run instead of app.run

Solution

1. Step 1: Check imports and app definition

   The code uses 'app' but does not import or define it anywhere.

2. Step 2: Confirm socketio.run usage

   socketio.run(app) is correct to run the app with SocketIO support.

3. Final Answer:

   Missing import of Flask app -> Option B

4. Quick Check:

   Undefined app variable = Missing import of Flask app [OK]

Hint: Always define or import Flask app before using it [OK]

Common Mistakes:

• Confusing socketio.run with app.run
• Thinking event handlers must return values
• Assuming 'connect' event handler is mandatory

5. You want to replace Server-Sent Events with Flask-SocketIO for a chat app. Which approach correctly handles broadcasting a message to all connected clients?

hard

A. Use socketio.emit('chat', message, broadcast=True) inside an event handler

B. Use emit('chat', message) without broadcast inside the handler

C. Use socketio.send(message) without event name

D. Use app.run() with broadcast=True parameter

Solution

1. Step 1: Understand broadcasting in Flask-SocketIO

   To send a message to all clients, use socketio.emit with broadcast=True.

2. Step 2: Evaluate options for broadcasting

   Use socketio.emit('chat', message, broadcast=True) inside an event handler correctly uses socketio.emit with event name and broadcast flag.

3. Final Answer:

   Use socketio.emit('chat', message, broadcast=True) inside an event handler -> Option A

4. Quick Check:

   Broadcast all clients = socketio.emit with broadcast=True [OK]

Hint: Broadcast with socketio.emit and broadcast=True [OK]

Common Mistakes:

• Omitting broadcast=True to send to all clients
• Using emit without socketio object for broadcast
• Trying to broadcast via app.run parameters