Background tasks in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a background task is added in FastAPI?

Consider this FastAPI endpoint using BackgroundTasks. What is the behavior of the background task?

FastAPI

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def write_log(message: str):
    with open("log.txt", "a") as f:
        f.write(message + "\n")

@app.post("/send")
async def send_message(background_tasks: BackgroundTasks, msg: str):
    background_tasks.add_task(write_log, msg)
    return {"message": "Message received"}

A The write_log function runs after the response is sent, without blocking the client.

B The write_log function runs in a separate thread and blocks the response until finished.

C The write_log function runs only if the client waits for the response.

D The write_log function runs immediately before the response is sent.

💡 Hint

Background tasks run after the response is sent to the client.

FastAPI's BackgroundTasks run after the response is sent, allowing the client to get a quick response while the task runs asynchronously in the background.

📝 Syntax

intermediate

Which option correctly adds a background task in FastAPI?

Given the function def cleanup(): ..., which code snippet correctly adds it as a background task in a FastAPI endpoint?

FastAPI

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def cleanup():
    print("Cleaning up")

@app.get("/clean")
async def clean(background_tasks: BackgroundTasks):
    # Add cleanup as background task
    pass

A background_tasks.add_task(cleanup())

B background_tasks.add_task(cleanup)

C background_tasks.add(cleanup)

D background_tasks.run(cleanup)

💡 Hint

Remember to pass the function itself, not call it.

The add_task method expects a function reference, not the result of calling the function.

🔧 Debug

advanced

Why does this background task not run as expected?

Examine the code below. The background task is supposed to write to a file, but the file remains empty. What is the cause?

FastAPI

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def write_log():
    with open("log.txt", "a") as f:
        f.write("Logged\n")

@app.post("/log")
async def log(background_tasks: BackgroundTasks):
    background_tasks.add_task(write_log())
    return {"status": "ok"}

A The endpoint must be synchronous to use background tasks.

B The file path "log.txt" is invalid, so no write occurs.

C BackgroundTasks cannot run synchronous functions like write_log.

D The write_log function is called immediately, so the task is None and not scheduled.

💡 Hint

Check how the function is passed to add_task.

Calling write_log() runs it immediately and passes its return (None) to add_task. The task is not scheduled. Instead, pass the function reference write_log without parentheses.

❓ state_output

advanced

What is the content of the file after calling this endpoint twice?

Given the code below, what will be the content of log.txt after two POST requests to /send with messages "Hello" and "World"?

FastAPI

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def write_log(message: str):
    with open("log.txt", "a") as f:
        f.write(message + "\n")

@app.post("/send")
async def send(background_tasks: BackgroundTasks, msg: str):
    background_tasks.add_task(write_log, msg)
    return {"status": "sent"}

A

log.txt contains:
Hello
World

B

log.txt contains:
World
Hello

C

log.txt contains:
HelloWorld

D log.txt is empty because background tasks run asynchronously.

💡 Hint

Background tasks append messages in order of requests.

Each call appends the message with a newline. After two calls with "Hello" and "World", the file has two lines in that order.

🧠 Conceptual

expert

What is a key limitation of FastAPI BackgroundTasks compared to Celery or other task queues?

Choose the correct statement about FastAPI's BackgroundTasks compared to external task queues like Celery.

A BackgroundTasks run in a separate worker process managed by FastAPI.

B BackgroundTasks automatically retry failed tasks with exponential backoff.

C BackgroundTasks run in the same process and will be lost if the server restarts.

D BackgroundTasks support distributed task scheduling across multiple servers.

💡 Hint

Think about persistence and reliability of tasks.

FastAPI BackgroundTasks run in the same server process and do not survive server restarts or crashes. External queues like Celery provide persistence, retries, and distributed processing.