DEVPREP CODEX · #08

FastAPI Interview Questions

150 curated questions graded from Foundations (Easy) to Practical Patterns (Medium) and Internals & Architecture (Hard).

TOTAL QUESTIONS

150

THEORY QUESTIONS

150

IMPLEMENTATION FOLIOS

FREE QUESTIONS

5 / Level

Easy Level·50 Questions Total

Foundations & Core Concepts

Open Full Easy List

Q1What is FastAPI and what makes it popular?

A modern Python framework for building APIs on standard type hints (ASGI-based, via Starlette + Pydantic).
Headline features: automatic validation from annotations, interactive docs (Swagger/ReDoc) generated free, async-first performance, dependency injection system.
Popularity drivers: near-Node throughput with Python ergonomics, minimal boilerplate, editor autocompletion because everything is typed.

Q2What role do type hints play in FastAPI?

They ARE the framework contract: parameters annotated int, UUID, Pydantic models drive parsing, validation, serialization and the OpenAPI schema.
Wrong types yield automatic 422 responses with precise error locations — no manual checking code.
Editors autocomplete everything; mypy catches mismatches pre-runtime. Interview line: "In FastAPI you don't validate inputs; you DECLARE them."

Q3What is a path operation? Show a basic example.

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
    return {"item_id": item_id, "q": q}

Decorator binds HTTP method + path to function (@app.get/post/put/delete).
Path parameter typed int → auto-conversion/validation.
Optional query param q defaults None; return dict auto-serialized to JSON.

Q4How do query parameters work?

Function params not in path become query params: def list(skip: int = 0, limit: int = Query(default=10, le=100)).
Constraints via Query(gt=0, max_length=...); alias support maps external names to pythonic ones.
Multiple values: tags: list[str] = Query([]) accepts ?tags=a&tags=b.

Q5How do request bodies work with Pydantic models?

class ItemIn(BaseModel):
    name: str
    price: float = Field(gt=0)
    tags: set[str] = set()

@app.post("/items")
async def create(item: ItemIn): ...

POST/PUT body parsed into the model automatically; nested models validated recursively.
Extra fields forbidden/configurable (model_config = ConfigDict(extra="forbid")).
Response model (response_model=ItemOut) filters output shape separately from input.

45 More Easy Questions Locked

Unlock the complete FastAPI Easy question bank

Get instant access to all 50 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Medium Level·50 Questions Total

Mechanisms & Practical Patterns

Open Full Medium List

Q1Explain the ASGI lifecycle and how FastAPI fits into it.

ASGI defines a single callable async def app(scope, receive, send) handling HTTP/WebSocket/lifespan messages.
Lifespan events (@app.on_event("startup") legacy / lifespan context manager modern) initialize pools (DB, Redis, httpx clients) once per process — dependencies then reuse them.
Uvicorn manages the event loop; multiple worker processes each run the full lifespan. Interview depth: explain why per-request engine creation is an anti-pattern vs lifespan-held pools.

Q2How does the dependency injection cache work and when do you bust it?

Within ONE request, identical dependency (by callable identity + params) resolves once — Depends(get_db) in handler + sub-dependency shares the session.
Bust via use_cache=False on Depends when you genuinely need fresh resolution (per-item security checks in loops).
Global scope alternative: module-level singletons for cross-request sharing (connection pools) — DI is for per-request composition.

Q3Compare yield-dependencies with try/finally and their cleanup timing.

async def get_db():
    async with async_session() as s:
        yield s

Code before yield runs pre-handler; after-yield executes AFTER response completes (exit of context), enabling commit/rollback decisions based on exceptions propagated from handlers.
Caveat: background tasks using that dependency may outlive — FastAPI handles ordering but long tasks should open own sessions. Exception injection: raising inside post-yield wraps handler errors — understand interplay with custom exception middleware.

Q4How do class-based dependencies and security scopes work?

class RoleChecker:
    def __init__(self, *roles): self.roles = set(roles)
    def __call__(self, user: User = Depends(get_current_user)):
        if user.role not in self.roles: raise HTTPException(403)

@router.post("/admin", dependencies=[Depends(RoleChecker("admin"))])

Callable instances become parameterized dependencies — reusable guards.
OAuth2 scopes: Security(get_current_user, scopes=["items:write"]); token contains scopes; SecurityScopes dependency verifies hierarchy — maps to OpenAPI security UI.

Q5What are Pydantic validators v2 and how do model_validator modes differ?

@field_validator("email")
@classmethod
def normalize(cls, v): return v.lower()

@model_validator(mode="after")
def check_dates(self):
    if self.end < self.start: raise ValueError(...)

field_validator runs per-field pre/post coercion (mode="before" sees raw input).
model_validator "before" receives raw dict (cross-field normalization), "after" receives constructed model instance. Return values replace data — forgetting to return in before-validators silently drops fields (classic bug).

45 More Medium Questions Locked

Unlock the complete FastAPI Medium question bank

Get instant access to all 50 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Hard Level·50 Questions Total

Internals & System Architecture

Open Full Hard List

Q1How does FastAPI's dependency resolution graph execute internally, and what edge cases bite?

Routes compile a dependency map at first request; solving walks sub-dependencies depth-first, honoring use_cache per node, injecting request-scoped values.
Edge bites: same callable imported via two module paths = two identities → double resolution; class dependencies instantiate per resolution unless cached; generator dependencies nest — cleanup order is reverse-resolution.
Security dependencies resolving BEFORE body validation: auth failures return 401 without parsing body (cheap reject path worth knowing).

Q2What does the event loop require from your handlers, and how do you prove compliance?

Requirement: never block. Proving: loop-lag monitor (asyncio debug clock drift), otel span gaps, py-spy showing handlers inside blocking frames.
Common offenders: requests/boto3/SQLAlchemy sync in async def, CPU-heavy JSON transforms, DNS via getaddrinfo.
Remedies: async-native libs, run_in_threadpool explicit for unavoidable blocks, process pools for CPU. CI guard: lint rules flagging known-blocking imports inside async functions.

Q3Explain contextvars propagation across tasks and middleware in FastAPI.

Each task copies context; contextvars set in middleware ARE visible in handler because middleware awaits downstream within same context chain — but background tasks spawn AFTER response may or may not inherit depending on creation site.
Starlette BaseHTTPMiddleware historically broke contextvar propagation into BackgroundTasks (new task context) — workarounds pass explicitly or use pure ASGI middleware.
OTel relies on contextvars — broken propagation silently disconnects traces.

Q4Compare BaseHTTPMiddleware vs pure ASGI middleware deeply.

BaseHTTPMiddleware wraps downstream as sub-task: enables easy request/response mutation but adds task overhead per request, historically breaks contextvars/background semantics and streaming backpressure.
Pure ASGI (scope, receive, send) sees message-level events: zero overhead, full control (modify send's http.response.start headers), but more boilerplate. Guidance: pure ASGI for hot-path cross-cutting (tracing, security headers); BaseHTTP acceptable for low-QPS conveniences.

Q5How would you implement distributed tracing end-to-end including async context?

OpenTelemetry auto-instrumentation (fastapi/sqlalchemy/httpx) creates server span → child client spans; manual spans via tracer.start_as_current_span for service boundaries.
Async correctness: context attached per task automatically by instrumentation; beware fire-and-forget tasks losing parent — inject context explicitly (attach(detached_context)).
Sampling strategy: head probabilistic + tail keep-errors/slow at collector; propagate traceparent outbound so partner services join traces.

45 More Hard Questions Locked