FASTAPI · HARD CODEX

FastAPI Interview Questions — Hard

Deep runtime internals, memory models, distributed design, concurrency failure modes, and architectural decisions.

50 Theory Questions5 Free Model Answers

THEORY QUESTIONS & SOLUTIONSShowing 5 of 50 questions

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.

Unlock the remaining 45 FastAPI (Hard) questions

You've completed the 5 free sample questions. Get unrestricted lifetime access to every question, model answer, implementation challenge, and all 27+ technologies for a single payment.

Unlock Everything — Already Enrolled? Sign In

One-time settlement () · Lifetime access · Zero subscription

CROSS-DIFFICULTY NAVIGATION

Continue Preparing FastAPI

EASY LEVEL

Foundations & Core Concepts

MEDIUM LEVEL

Mechanisms & Practical Patterns