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.

Practice

1. What does ASGI enable FastAPI to do compared to traditional synchronous frameworks?

easy

A. Use only synchronous functions for better speed

B. Run only one request at a time to avoid conflicts

C. Handle many requests at the same time using async code

D. Automatically convert Python code to JavaScript

Solution

1. Step 1: Understand ASGI's role

   ASGI is designed to handle multiple requests concurrently using asynchronous programming.

2. Step 2: Compare with synchronous frameworks

   Traditional synchronous frameworks handle one request at a time, blocking others until done.

3. Final Answer:

   Handle many requests at the same time using async code -> Option C

4. Quick Check:

   ASGI = concurrent async handling [OK]

Hint: ASGI means multitasking with async code [OK]

Common Mistakes:

• Thinking ASGI runs requests one by one
• Confusing ASGI with code conversion tools
• Believing async slows down the app

2. Which of the following is the correct way to define an async route handler in FastAPI?

easy

A. async def read_root(): return {"message": "Hello"}

B. def read_root(): return {"message": "Hello"}

C. async read_root(): return {"message": "Hello"}

D. def async read_root(): return {"message": "Hello"}

Solution

1. Step 1: Recall async function syntax

   In Python, async functions start with async def followed by the function name.

2. Step 2: Check each option's syntax

   async def read_root(): return {"message": "Hello"} correctly uses async def. Options C and D have invalid syntax. def read_root(): return {"message": "Hello"} is synchronous.

3. Final Answer:

   async def read_root(): return {"message": "Hello"} -> Option A

4. Quick Check:

   Async function = async def [OK]

Hint: Async functions start with 'async def' [OK]

Common Mistakes:

• Omitting 'def' after 'async'
• Placing 'async' after 'def'
• Using synchronous 'def' for async routes

3. Given this FastAPI route handler, what will be the output when accessed?

from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get("/wait")
async def wait_and_return():
    await asyncio.sleep(1)
    return {"status": "done"}

medium

A. Error because asyncio.sleep cannot be awaited

B. Immediate response with {"status": "done"}

C. Server crashes due to blocking call

D. {"status": "done"} after 1 second delay

Solution

1. Step 1: Understand async sleep behavior

   The function uses await asyncio.sleep(1), which pauses the function asynchronously for 1 second.

2. Step 2: Predict response timing

   The response will be sent after the 1 second delay, returning the JSON with status done.

3. Final Answer:

   {"status": "done"} after 1 second delay -> Option D

4. Quick Check:

   Await asyncio.sleep = delayed async response [OK]

Hint: Await asyncio.sleep delays response asynchronously [OK]

Common Mistakes:

• Thinking await asyncio.sleep blocks all requests
• Expecting immediate response ignoring await
• Confusing asyncio.sleep with time.sleep

4. Identify the error in this FastAPI async route handler:

from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get("/error")
def error_route():
    await asyncio.sleep(1)
    return {"message": "done"}

medium

A. Missing async keyword before function definition

B. Cannot use await inside async function

C. FastAPI does not support async routes

D. Return statement must be inside try-except block

Solution

1. Step 1: Check function definition

   The function uses await but is defined without async, which is invalid syntax.

2. Step 2: Understand async function requirements

   To use await, the function must be declared with async def.

3. Final Answer:

   Missing async keyword before function definition -> Option A

4. Quick Check:

   Await requires async def [OK]

Hint: Use async def when using await inside function [OK]

Common Mistakes:

• Forgetting async before def
• Thinking await works in sync functions
• Believing FastAPI disallows async routes

5. You want to create a FastAPI endpoint that fetches data from two slow APIs concurrently to improve speed. Which approach best uses FastAPI's async-first architecture?

hard

A. Use async functions with await on both API calls sequentially

B. Use asyncio.gather to run both async API calls concurrently inside an async route

C. Call both APIs one after another using synchronous requests inside an async function

D. Run synchronous API calls in separate threads without async

Solution

1. Step 1: Understand concurrency with async

   Calling APIs sequentially with await waits for each to finish before starting the next, not concurrent.

2. Step 2: Use asyncio.gather for concurrency

   asyncio.gather runs multiple async tasks at the same time, improving speed.

3. Step 3: Compare options

   Use asyncio.gather to run both async API calls concurrently inside an async route uses asyncio.gather inside async route, best leveraging FastAPI's async-first design.

4. Final Answer:

   Use asyncio.gather to run both async API calls concurrently inside an async route -> Option B

5. Quick Check:

   asyncio.gather = concurrent async calls [OK]

Hint: Use asyncio.gather for concurrent async calls [OK]

Common Mistakes:

• Awaiting calls sequentially losing concurrency
• Using synchronous calls blocking event loop
• Ignoring async and threading differences