Async vs sync decision in FastAPI - Practice Questions

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when mixing async and sync endpoints in FastAPI?

Consider a FastAPI app with one async endpoint and one sync endpoint. What happens when both are called concurrently?

FastAPI

from fastapi import FastAPI
import time
import asyncio

app = FastAPI()

@app.get('/sync')
def sync_endpoint():
    time.sleep(1)
    return {'message': 'sync done'}

@app.get('/async')
async def async_endpoint():
    await asyncio.sleep(1)
    return {'message': 'async done'}

A Both endpoints block independently; sync blocks the server thread, async allows concurrency.

B Both endpoints run concurrently without blocking each other.

C Sync endpoint runs asynchronously, async endpoint runs synchronously.

D Both endpoints block the server and cause a deadlock.

💡 Hint

Think about how Python handles time.sleep vs asyncio.sleep in FastAPI.

The sync endpoint uses time.sleep, which blocks the server thread, preventing other requests from running concurrently on that thread. The async endpoint uses await asyncio.sleep, which allows the event loop to switch tasks and handle other requests concurrently.

📝 Syntax

intermediate

Which FastAPI endpoint definition is correct for async behavior?

Select the correct FastAPI endpoint definition that properly uses async syntax.

A @app.get('/data')\ndef get_data():\n return {'data': await some_async_call()}

B @app.get('/data')\ndef get_data():\n await some_async_call()\n return {'data': 'async'}

C @app.get('/data')\nasync def get_data():\n time.sleep(1)\n return {'data': 'async'}

D @app.get('/data')\nasync def get_data():\n return {'data': 'async'}

💡 Hint

Remember that 'await' can only be used inside async functions.

Option D correctly defines an async function without blocking calls. Option D uses 'await' inside a sync function, causing a syntax error. Option D uses blocking time.sleep inside async, which blocks the event loop. Option D uses 'await' outside async function, causing syntax error.

❓ state_output

advanced

What is the output of this FastAPI async endpoint with blocking code?

Analyze the output and behavior of this endpoint when called multiple times concurrently.

FastAPI

from fastapi import FastAPI
import time
import asyncio

app = FastAPI()

@app.get('/block')
async def block_endpoint():
    time.sleep(2)
    return {'status': 'done'}

A The endpoint raises a RuntimeWarning but returns immediately.

B Requests run concurrently without blocking despite time.sleep usage.

C Each request blocks the event loop for 2 seconds, causing all requests to be processed sequentially.

D The server crashes due to mixing sync blocking code in async function.

💡 Hint

Consider what happens when blocking code runs inside an async function.

Using time.sleep inside an async function blocks the entire event loop, so all requests wait for the blocking call to finish, resulting in sequential processing.

🔧 Debug

advanced

Why does this FastAPI async endpoint cause slow responses?

Identify the cause of slow responses in this async endpoint code.

FastAPI

from fastapi import FastAPI
import time
import asyncio

app = FastAPI()

@app.get('/slow')
async def slow_endpoint():
    for _ in range(3):
        time.sleep(1)
    return {'message': 'done'}

A The for loop is not awaited causing the function to run synchronously.

B Using time.sleep inside async blocks the event loop causing slow responses.

C Missing await before time.sleep causes the function to hang.

D The endpoint lacks async keyword causing slow execution.

💡 Hint

Check which calls block the event loop in async functions.

time.sleep is a blocking call and should not be used inside async functions. It pauses the event loop, causing slow responses.

🧠 Conceptual

expert

When should you choose sync over async endpoints in FastAPI?

Select the best scenario to use synchronous endpoints instead of asynchronous ones in FastAPI.

A When the endpoint performs CPU-bound tasks that do not benefit from async concurrency.

B When the endpoint makes many network calls that support async operations.

C When you want to maximize concurrency for I/O-bound tasks.

D When the endpoint uses async libraries exclusively.

💡 Hint

Think about the nature of the task: CPU-bound vs I/O-bound.

Async endpoints help with I/O-bound tasks by allowing concurrency. CPU-bound tasks block the event loop and do not benefit from async, so sync endpoints are better for CPU-heavy work.