ASGI and async-first architecture in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI async endpoint?

Consider this FastAPI endpoint using async def. What will the client receive when calling /hello?

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get('/hello')
async def hello():
    return {'message': 'Hello, async world!'}

A {"message": "Hello, async world!"}

B Hello, async world!

C An error because async functions cannot return dict

D A JSON string with key 'hello' and value 'world'

💡 Hint

Remember that FastAPI automatically converts dict returns to JSON responses.

The async endpoint returns a Python dictionary. FastAPI converts this dict to a JSON response automatically. So the client receives a JSON object with the key 'message' and the value 'Hello, async world!'.

❓ lifecycle

intermediate

What happens when an async FastAPI endpoint awaits a slow function?

Given this code, what is the behavior when a client calls /wait?

from fastapi import FastAPI
import asyncio
app = FastAPI()

@app.get('/wait')
async def wait():
    await asyncio.sleep(2)
    return {'status': 'done'}

A The server blocks all other requests for 2 seconds before responding

B The client receives an immediate empty response, then the final response after 2 seconds

C The server crashes because asyncio.sleep cannot be awaited

D The server handles other requests during the 2 seconds wait asynchronously

💡 Hint

Think about how async functions allow other tasks to run while waiting.

Using await asyncio.sleep(2) pauses this endpoint without blocking the server. Other requests can be handled during this wait time because FastAPI uses async-first architecture.

📝 Syntax

advanced

Which option will cause a syntax error in this async FastAPI endpoint?

Identify the option that will cause a syntax error when defining an async FastAPI endpoint.

FastAPI

from fastapi import FastAPI
app = FastAPI()

A

@app.get('/test')
def test():
    await some_async_func()
    return {'msg': 'ok'}

B

@app.get('/test')
async def test():
    return {'msg': 'ok'}

C

@app.get('/test')
async def test():
    await some_async_func()
    return {'msg': 'ok'}

D

}'ko' :'gsm'{ nruter    
:)(tset fed cnysa
)'tset/'(teg.ppa@

💡 Hint

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

Option A defines a normal function (def) but uses 'await' inside it, which is invalid syntax. 'await' must be inside an async function.

🔧 Debug

advanced

Why does this FastAPI async endpoint raise a RuntimeError?

Examine this code snippet. Why does calling /error raise a RuntimeError?

from fastapi import FastAPI
import asyncio
app = FastAPI()

@app.get('/error')
def error():
    asyncio.create_task(asyncio.sleep(1))
    return {'status': 'started'}

A Because asyncio.sleep cannot be used in FastAPI endpoints

B Because asyncio.create_task must be called inside an async function

C Because the endpoint is missing an await keyword

D Because FastAPI does not support background tasks

💡 Hint

Check where asyncio.create_task is allowed to run.

asyncio.create_task requires an active event loop, which is only available inside async functions. Calling it in a normal def function causes a RuntimeError.

🧠 Conceptual

expert

What is the main advantage of ASGI over WSGI in FastAPI's async-first architecture?

Choose the best explanation for why FastAPI uses ASGI instead of WSGI.

A ASGI only supports synchronous code which improves stability

B ASGI is simpler to implement and requires less code than WSGI

C ASGI supports asynchronous concurrency allowing multiple requests to be handled simultaneously without blocking

D ASGI automatically caches all responses to speed up the server

💡 Hint

Think about how async code benefits server concurrency.

ASGI supports asynchronous concurrency, enabling FastAPI to handle many requests at once without waiting for slow operations. WSGI is synchronous and blocks during long tasks.