How does the request lifecycle work in FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI runs on **ASGI**, so a request travels through an async pipeline: the ASGI server accepts it, middleware wraps it, the router matches a path, **dependencies are resolved**, your path operation runs, and the return value is serialized into the response.

## The stages

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── match method + path → path operation
   ▼
Dependencies (Depends)  ── resolve sub-deps, security, yield-setup
   ▼
Path operation function  ── your handler runs
   ▼
Response model  ── validate + serialize to JSON
   ▼
Background tasks  ── run after the response is sent
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) accepts the connection and passes a `scope` plus `receive`/`send` callables to the app.
2. **Middleware** runs outside-in on the way in and inside-out on the way out (`BaseHTTPMiddleware` or pure ASGI middleware). CORS, GZip, and custom timing live here.
3. **Routing** matches the HTTP method + path to a path operation; path/query/body params are extracted and validated by **Pydantic**.
4. **Dependency injection** — `Depends(...)` resolves each dependency (DB session, current user, settings), caching within the request. A dependency with `yield` runs setup before and teardown after the handler.
5. **Path operation** — your `async def` (or `def`, run in a threadpool) executes the business logic.
6. **Response** — the return value is coerced to the declared `response_model`, validated, and serialized to JSON; status code and headers are applied.
7. **Background tasks** registered via `BackgroundTasks` run *after* the response is sent.

```python
from fastapi import FastAPI, Depends, Request

app = FastAPI()

@app.middleware("http")
async def timing(request: Request, call_next):   # 2. middleware
    response = await call_next(request)
    response.headers["X-Time"] = "..."
    return response

async def get_db():                               # 4. dependency (yield)
    db = Session()
    try:
        yield db
    finally:
        db.close()

@app.get("/items/{id}")                           # 3. routing
async def read_item(id: int, db=Depends(get_db)): # 5. handler
    return db.get(Item, id)                        # 6. serialized via response_model
```

Exceptions are caught by **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), which convert them into responses instead of crashing the request.

## Why it matters

The request lifecycle is where FastAPI's headline features actually happen: async I/O, Pydantic validation, and dependency injection all hook into specific stages. Knowing the order — middleware, then routing, then dependencies, then handler, then serialization — lets you put cross-cutting logic in the right place (auth as a dependency, timing as middleware, cleanup in a `yield` dependency), debug why a validation or auth error fires before your code runs, and avoid blocking the event loop inside an async handler.

The stages

Why it matters

Related questions