FastAPI Architecture (Request to Response Lifecycle)

FastAPI is a modern, high-performance web framework used to build APIs with Python 3.8+ based on standard Python type hints.

High-Level Architecture

Step 1: Client Sends an HTTP Request

GET /users/1 HTTP/1.1
Host: localhost:8000

curl http://localhost:8000/users/1

An ASGI (Asynchronous Server Gateway Interface) server is a Python standard that enables web servers to communicate with asynchronous web applications and frameworks. It acts as the modern successor to WSGI, allowing you to handle multiple concurrent connections and real-time protocols like WebSockets.

Step 2: Uvicorn Receives the Request

uvicorn main:app --reload

Step 3: Uvicorn Converts HTTP Request into ASGI Messages

{
    "type": "http",
    "method": "GET",
    "path": "/users/1",
    "headers": [...]
}

Step 4: FastAPI Receives the Request

from fastapi import FastAPI
app = FastAPI()

Step 5: Middleware Execution Begins

from fastapi import FastAPI, Request

app = FastAPI()

@app.middleware("http")
async def log_request(request: Request, call_next):

    print("Request received")
    response = await call_next(request)
    print("Response generated")

    return response

Step 6: Route Matching

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    return {"id": user_id}

Step 7: Dependency Injection Resolution

from fastapi import Depends

async def get_db():
    return "database"

@app.get("/users")
async def get_users(db=Depends(get_db)):
    return {"db": db}

Step 8: Request Validation Using Pydantic

from pydantic import BaseModel

class UserRequest(BaseModel):
    name: str
    age: int

@app.post("/users")
async def create_user(user: UserRequest):
    return user

{
    "name": "John",
    "age": 30
}

{
    "name": "John",
    "age": "abc"
}

{
    "detail": [...]
}

Step 9: Endpoint Execution

@app.get("/users/{id}")
async def get_user(id: int):
    return {
        "id": id,
        "name": "John"
    }

# Step 10: Response Serialization

return {
    "id": 1,
    "name": "John"
}

{
    "id": 1,
    "name": "John"
}

Step 11: Response Model Validation

class UserResponse(BaseModel):
    id: int
    name: str

@app.get("/users/{id}",
         response_model=UserResponse)
async def get_user(id: int):
    return {
        "id": id,
        "name": "John"
    }

Step 12: Exception Handling

from fastapi import HTTPException

@app.get("/users/{id}")
async def get_user(id: int):

    raise HTTPException(
        status_code=404,
        detail="User not found"
    )

{
    "detail": "User not found"
}

Step 13: Middleware Executes Again

Step 14: Uvicorn Sends Response to Client

HTTP/1.1 200 OK
Content-Type: application/json

{
    "id": 1,
    "name": "John"
}

Complete End-to-End Example

from fastapi import FastAPI
from fastapi import Depends
from pydantic import BaseModel

app = FastAPI()

class UserResponse(BaseModel):
    id: int
    name: str

async def get_db():
    return "db_connection"


@app.middleware("http")
async def logging(request, call_next):
    print("Incoming request")
    response = await call_next(request)
    print("Outgoing response")
    return response

@app.get(
    "/users/{user_id}",
    response_model=UserResponse
)
async def get_user(
        user_id: int,
        db=Depends(get_db)
):
    return {
        "id": user_id,
        "name": "John"
    }

Interview Q&A

Conclusion