Background file processing 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 code snippet that uploads a file and starts a background task to process it. What is the behavior of the endpoint when a file is uploaded?

FastAPI

from fastapi import FastAPI, UploadFile, BackgroundTasks

app = FastAPI()

def process_file(file_path: str):
    # Simulate file processing
    with open(file_path, 'r') as f:
        data = f.read()
    print(f"Processed file with length: {len(data)}")

@app.post('/upload')
async def upload_file(background_tasks: BackgroundTasks, file: UploadFile):
    file_location = f"./temp/{file.filename}"
    with open(file_location, 'wb') as buffer:
        buffer.write(await file.read())
    background_tasks.add_task(process_file, file_location)
    return {"message": "File received, processing started"}

A The endpoint returns an error because background tasks cannot be used with file uploads.

B The endpoint waits until the file processing finishes before returning the response.

C The endpoint immediately returns the response while the file processing runs in the background.

D The file processing runs synchronously before the file is saved.

💡 Hint

Think about how FastAPI handles background tasks and response timing.

FastAPI's BackgroundTasks run after the response is sent. So the endpoint returns immediately, and the file processing happens asynchronously in the background.

📝 Syntax

intermediate

Identify the syntax error in this FastAPI background task usage

Which option contains a syntax error that prevents the background task from being added correctly?

FastAPI

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def task(name: str):
    print(f"Hello {name}")

@app.get('/start')
async def start(background_tasks: BackgroundTasks):
    background_tasks.add_task(task, 'User')
    return {"status": "started"}

A background_tasks.add_task(task, ['User'])

B background_tasks.add_task(task, 'User')

C background_tasks.add_task(task, name='User')

D background_tasks.add_task(task 'User')

💡 Hint

Check the syntax of function calls and argument passing.

Option D misses a comma between the function and argument, causing a syntax error.

❓ state_output

advanced

What is printed when multiple background tasks modify a shared list?

Given this FastAPI code, what will be the final content of the shared list after the endpoint is called once?

FastAPI

from fastapi import FastAPI, BackgroundTasks
import time

app = FastAPI()
shared_list = []

def add_item(item: str):
    time.sleep(0.1)
    shared_list.append(item)

@app.get('/add')
async def add(background_tasks: BackgroundTasks):
    background_tasks.add_task(add_item, 'A')
    background_tasks.add_task(add_item, 'B')
    return {"message": "Tasks started"}

A ['B', 'A']

B ['A', 'B']

C []

D ['A']

💡 Hint

Background tasks run after response, but order of execution is preserved.

Background tasks are added in order and run sequentially, so 'A' is appended before 'B'.

🔧 Debug

advanced

Why does this background task fail to process the uploaded file?

This FastAPI code tries to process an uploaded file in the background but fails. What is the cause?

FastAPI

from fastapi import FastAPI, UploadFile, BackgroundTasks

app = FastAPI()

def process_file(file: UploadFile):
    content = file.file.read()
    print(f"File content length: {len(content)}")

@app.post('/upload')
async def upload(background_tasks: BackgroundTasks, file: UploadFile):
    background_tasks.add_task(process_file, file)
    return {"message": "Processing started"}

A The UploadFile object is closed before the background task runs, so reading fails.

B BackgroundTasks cannot accept functions with parameters.

C The process_file function must be async to work as a background task.

D The file content must be saved to disk before processing.

💡 Hint

Think about the lifecycle of UploadFile and when its file handle is available.

UploadFile's file is closed after the request ends, so background tasks cannot read it unless saved first.

🧠 Conceptual

expert

Which statement about FastAPI background tasks and concurrency is true?

Select the correct statement about how FastAPI handles background tasks and concurrency.

A Background tasks run after the response is sent but share the same event loop, so CPU-bound tasks can block the server.

B Background tasks run in separate threads and can safely modify shared memory without locks.

C Background tasks run in separate processes automatically to avoid blocking the main server.

D Background tasks are executed synchronously before the response is returned.

💡 Hint

Consider how FastAPI uses async and the Python event loop for background tasks.

FastAPI background tasks run after response on the same event loop; CPU-heavy tasks can block unless offloaded.