Polling as fallback in Flask - Mini Project: Build & Apply

Polling as fallback in Flask

📖 Scenario: You are building a simple Flask web app that shows the current server time updating every few seconds. Normally, you would use WebSockets for live updates, but as a fallback, you want to use polling to fetch the time repeatedly.

🎯 Goal: Create a Flask app with a route that returns the current server time as JSON. Then add a polling mechanism in the HTML page using JavaScript to fetch and display the time every 5 seconds.

📋 What You'll Learn

Create a Flask route /time that returns the current time in JSON format with key time

Create a basic HTML page served at / with a placeholder element to show the time

Add a JavaScript polling function that fetches /time every 5 seconds

Update the placeholder element with the fetched time on each poll

💡 Why This Matters

🌍 Real World

Polling is a simple fallback method to get live updates from a server when more advanced methods like WebSockets are not available or supported.

💼 Career

Understanding polling helps you build robust web apps that work reliably across different browsers and network conditions, a useful skill for frontend and backend developers.

1

Set up Flask app and time route

Create a Flask app instance called app. Then create a route @app.route('/time') that returns a JSON response with the current server time under the key 'time'. Use datetime.now().strftime('%H:%M:%S') to format the time string.

Flask

# Your code here

Hint

Import Flask and jsonify from flask, and datetime from datetime. Create the app and define the route returning JSON with the current time.

2

Add HTML page with time display placeholder

Add a route @app.route('/') that returns a simple HTML page as a string. The page should have a <div> with id='time-display' where the time will be shown. Include a <script> tag placeholder for JavaScript below the div.

Flask

from flask import Flask, jsonify
from datetime import datetime

app = Flask(__name__)

@app.route('/time')
def get_time():
    current_time = datetime.now().strftime('%H:%M:%S')
    return jsonify({'time': current_time})

# Your code here

Hint

Define the / route returning HTML with a div having id='time-display' and an empty script tag below it.

3

Add JavaScript polling function

Inside the <script> tag in the HTML returned by index(), add a JavaScript function called pollTime() that uses fetch('/time') to get the JSON time, then updates the innerText of the element with id='time-display'. Use setInterval to call pollTime() every 5000 milliseconds (5 seconds). Also call pollTime() once immediately to show time on page load.

Flask

from flask import Flask, jsonify
from datetime import datetime

app = Flask(__name__)

@app.route('/time')
def get_time():
    current_time = datetime.now().strftime('%H:%M:%S')
    return jsonify({'time': current_time})

@app.route('/')
def index():
    return '''
    
      
        Loading time...
        
          // Your code here
        
      
    
    '''

Hint

Write a JavaScript function pollTime() that fetches /time, parses JSON, updates the div text, calls it once, and sets interval every 5 seconds.

4

Run the Flask app with debug mode

Add the standard Flask app runner code at the bottom: if __name__ == '__main__': then app.run(debug=true) to start the server in debug mode.

Flask

from flask import Flask, jsonify
from datetime import datetime

app = Flask(__name__)

@app.route('/time')
def get_time():
    current_time = datetime.now().strftime('%H:%M:%S')
    return jsonify({'time': current_time})

@app.route('/')
def index():
    return '''
    
      
        Loading time...
        
          function pollTime() {
            fetch('/time')
              .then(response => response.json())
              .then(data => {
                document.getElementById('time-display').innerText = data.time;
              });
          }
          pollTime();
          setInterval(pollTime, 5000);
        
      
    
    '''

# Your code here

Hint

Add the standard Flask app runner block to start the server with debug mode enabled.

Practice

1. What is the main reason to use polling as a fallback in Flask applications?

easy

A. To regularly ask the server for updates when real-time methods fail

B. To reduce the number of server requests to zero

C. To make the server push updates automatically without client requests

D. To avoid any communication between client and server

Solution

1. Step 1: Understand polling purpose

   Polling sends repeated requests to the server to check for updates.

2. Step 2: Identify fallback use

   Polling is used when real-time communication methods like WebSockets are unavailable or fail.

3. Final Answer:

   To regularly ask the server for updates when real-time methods fail -> Option A

4. Quick Check:

   Polling = fallback for updates [OK]

Hint: Polling means repeated requests when real-time fails [OK]

Common Mistakes:

• Thinking polling reduces server requests
• Confusing polling with server push
• Believing polling stops communication

2. Which Flask code snippet correctly implements a simple polling endpoint that returns JSON data?

easy

A. from flask import Flask
app = Flask(__name__)

@app.route('/poll')
def poll():
return {'status': 'ok', 'time': datetime.now()}

B. from flask import Flask
app = Flask(__name__)

@app.route('/poll')
def poll():
return 'status: ok'

C. from flask import Flask, json
app = Flask(__name__)

@app.route('/poll')
def poll():
return json.dumps({'status': 'ok'})

D. from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/poll')
def poll():
return jsonify({'status': 'ok'})

Solution

1. Step 1: Check Flask imports and response format

   Using jsonify is the correct way to return JSON responses in Flask.

2. Step 2: Verify route and function syntax

   from flask import Flask, jsonify app = Flask(__name__) @app.route('/poll') def poll(): return jsonify({'status': 'ok'}) uses @app.route and returns jsonify({'status': 'ok'}) correctly.

3. Final Answer:

   Correct Flask polling endpoint returning JSON with jsonify -> Option D

4. Quick Check:

   jsonify for JSON response = from flask import Flask, jsonify app = Flask(__name__) @app.route('/poll') def poll(): return jsonify({'status': 'ok'}) [OK]

Hint: Use jsonify to return JSON responses in Flask [OK]

Common Mistakes:

• Returning plain string instead of JSON
• Using json.dumps without Response object
• Returning dict directly without jsonify

3. Given this Flask polling endpoint code, what will the client receive when requesting '/poll'?

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/poll')
def poll():
    data = {'message': 'Hello', 'count': 5}
    return jsonify(data)

medium

A. Hello 5

B. {"message": "Hello", "count": 5}

C. {message: Hello, count: 5}

D. Error: jsonify not defined

Solution

1. Step 1: Understand jsonify output

   jsonify converts Python dict to JSON string with double quotes and correct syntax.

2. Step 2: Check returned data format

   The returned JSON string will be {"message": "Hello", "count": 5} as a JSON response.

3. Final Answer:

   {"message": "Hello", "count": 5} -> Option B

4. Quick Check:

   jsonify returns JSON string = {"message": "Hello", "count": 5} [OK]

Hint: jsonify returns JSON string with double quotes [OK]

Common Mistakes:

• Expecting plain text instead of JSON
• Confusing Python dict syntax with JSON
• Assuming jsonify is undefined

4. Identify the error in this Flask polling endpoint code:

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/poll')
def poll():
    data = {'status': 'ok'}

medium

A. Function poll() is missing a return statement

B. Missing @app.route decorator

C. Flask app is not created properly

D. Returning a dict directly without using jsonify causes an error

Solution

1. Step 1: Check for return statement

   The poll() function defines data but does not return it.

2. Step 2: Verify function completeness

   Missing return statement means the endpoint returns None by default, causing unexpected empty response.

3. Final Answer:

   Function poll() is missing a return statement -> Option A

4. Quick Check:

   Missing return in view function [OK]

Hint: Always include return statement in Flask route handlers [OK]

Common Mistakes:

• Missing return statement in route function
• Forgetting route decorator
• Not creating Flask app instance

5. You want to implement polling as a fallback in a Flask app that first tries WebSocket for real-time updates. Which approach correctly combines both methods?

hard

A. Use WebSocket and polling simultaneously without fallback logic

B. Only use polling and ignore WebSocket support

C. Use WebSocket for updates; if unsupported, client polls '/poll' endpoint every 5 seconds

D. Use polling only on the server side without client requests

Solution

1. Step 1: Understand fallback strategy

   Fallback means trying WebSocket first, then polling if WebSocket fails or is unsupported.

2. Step 2: Identify correct client-server interaction

   Client tries WebSocket; if it fails, client sends repeated requests to '/poll' endpoint every few seconds.

3. Final Answer:

   Use WebSocket for updates; if unsupported, client polls '/poll' endpoint every 5 seconds -> Option C

4. Quick Check:

   Fallback = WebSocket then polling [OK]

Hint: Try WebSocket first, then poll if needed [OK]

Common Mistakes:

• Ignoring fallback and using only polling
• Using polling without client requests
• Running both methods without fallback logic