Senior Python + AI — Technology Roadmap

Checklist format. Tick what you can explain and defend under questioning, not what you’ve used.

Every theme links to the notes that answer it. Same convention as Company B (AdTech) — prep map and Tech Check — Theme Navigation: tick the box once reviewed, bold is the primary note, the rest add depth.

Priority: 🔴 core (asked in most interviews) · 🟡 important (asked for your target roles) · 🟢 breadth (nice to have)

Layer 1 — Foundations

🔴 Python

Data model — __new__, __init__, descriptors, __slots____init__ vs __new____slots__Metaclasses __eq__ vs __hash__
MRO / C3 linearization, cooperative super()super() and the MRO staticmethod vs classmethod
Refcounting + generational GC, reference cycles, weakrefMemory model and GC weakrefMemory profiling
The GIL — what it protects and what it doesn’t; free-threaded buildsThe GIL Free-threading in 3.14 Why Python is slow
Generators, yield from, the iterator protocolGenerators and iterators
Context managers, contextlib, ExitStackcontextlibDecorators and context managers
functools — lru_cache traps, singledispatch, cached_propertyfunctoolsfunctools.wraps
dataclass vs attrs vs Pydantic — when eachdataclass vs attrs vs Pydantic dataclasses
Profiling — cProfile, py-spy, memrayProfiling basics Memory profiling Production debugging

🔴 Python Typing

Protocol vs ABC — structural vs nominalProtocol vs ABC
TypeVar, ParamSpec, Concatenate, genericsTypeVar and generics ParamSpec and Concatenate
@overload, TypedDict, Literal, SelfTypedDict and Literal Annotated and TypeGuard Optional and Union
Variance — covariant / contravariant / invariantTypeVar and generics(§ Variance)
PEP 695 syntax — class Foo[T], type X = ...TypeVar and generics(§ PEP 695 syntax)Free-threading in 3.14
mypy --strict / pyrightmypy vs pyright

🔴 Python Async

Coroutine vs Task vs FutureCoroutines Event loop internals Concurrency vs parallelism
TaskGroup (3.11+) vs gather vs as_completedTaskGroup
Cancellation semantics — CancelledError, shield, asyncio.timeout()Cancellation and timeouts
Blocking the event loop — detection and fixes (to_thread, executors)to_thread and executors CPU vs I/O bound Async optimisation
Backpressure — Semaphore, bounded QueueQueues Semaphores and locks
Strong task references — fire-and-forget is a GC bugTaskGroup Debugging async
anyio / structured concurrencyanyio and trio
Async DB — asyncpg, psycopg3, SQLAlchemy AsyncSessionAsync SQLAlchemy Async AWS

🔴 Testing

pytest fixtures, scopes, parametrize, conftestFixtures pytest concepts parametrize
monkeypatch / mock.patch — patch where it’s looked upmock and patch Mocking external APIs Test doubles
pytest-asyncio strict vs auto modepytest-asyncio
testcontainers — real Postgres/Redis in testsIntegration tests Contract testing
Hypothesis — property-based testingHypothesis
Coverage — and why 100% isn’t the goalCoverage Test pyramid

🔴 Git

Rebase vs merge — when eachMerge vs rebase
Interactive rebase — squash, fixup, reorder, editInteractive rebase
reflog — recovering “lost” commitsReflog recovery Dangerous commands
cherry-pick, revert vs reset — --soft / --mixed / --hardreset vs revert cherry-pick
bisect — regression huntingBisect
stash, worktreesStash Worktrees
Conflict resolution, rerereConflict resolution
Branching strategy — trunk-based vs GitFlowBranch strategies PR workflow
Conventional commits, pre-commit hooksHooks

🔴 Bash / Linux

Pipes, redirection, xargs, process substitutionPipes and redirection Find and xargs
grep / sed / awk / jq / findgrep / sed / awk Find and xargs
Process management — ps, top/htop, signals, kill, nohupProcess management Signals and traps
systemd basics, journalctlSystemd services Cron and systemd timers
Networking — curl, dig, netstat/ss, lsof, tcpdumpTroubleshooting tools
Permissions, users, chmod/chownFile permissions
Disk/memory — df, du, free, iostatProcess management Bash commands
Script hygiene — set -euo pipefail, traps, quotingExit codes and strict mode Quoting and expansion Bash scripting essentials
SSH, keys, tunnels, scp/rsyncSSH

🔴 Docker

Image vs container vs layer; layer caching orderDocker image layers Image vs container
Multi-stage builds, slim/distroless base imagesMulti-stage builds
.dockerignore, build context sizeDocker image layers Docker
Volumes vs bind mountsVolume types
Networking, port mapping, docker-composeDocker networking Docker compose
Healthchecks, restart policiesDocker compose Scaling in docker
ENTRYPOINT vs CMD, PID 1 and signal handlingDocker Signals and traps
Non-root users, secrets — never in ENVPurpose of containerization Secrets and supply chain
Image size optimisation for Lambda / ECSMulti-stage builds Lambda

🟢 Kubernetes

Pods, Deployments, Services, IngressPods and Deployments Ingress and networking
ConfigMaps, SecretsConfigMaps and Secrets
Liveness vs readiness probesProbes and HPA
Resource requests/limits, HPAProbes and HPA
kubectl debugging — logs, exec, describe, port-forwardKubernetes interview Kubernetes basics

Layer 2 — Backend

🔴 FastAPI

🔴 Pydantic v2

field_validator vs model_validator — before / after / wrapValidation modes
computed_field, model_config, from_attributesPydantic in practice Response models
Serialization aliases, exclude_unset / exclude_noneResponse models Pydantic in practice
pydantic-settings for configPydantic in practice Django settings
Request / response / DB model separationResponse models SQLModel
v1 → v2 migration differencesPydantic v1 to v2 dataclass vs attrs vs Pydantic

🔴 SQLAlchemy 2.0

Core vs ORM, select() styleCore vs ORM 2.0-style select()
Session lifecycle, identity map, unit of workSession lifecycle Unit of work Engine and session
Eager loading — selectinload, joinedload, subqueryloadLoading strategies The N+1 problem
Async session — and why lazy loading raisesAsync SQLAlchemy
Relationship config, cascadesRelationships Common pitfalls
Connection pooling — NullPool behind PgBouncerSQLAlchemy pooling Connection pooling
Alembic — autogenerate limits, data migrations, branchingAlembic Zero-downtime migrations

🟡 Django + DRF

QuerySet laziness and result cachingQuerySets Django ORM
select_related vs prefetch_related, Prefetch()select_related vs prefetch_related Django relationships
N+1 detection — assertNumQueries, debug toolbarN+1 in DRF The N+1 problem
F(), Q(), Subquery/OuterRef, annotate vs aggregateF()Q()Django ORM
transaction.atomic, select_for_update, on_commitDjango ORM Bulk operations SQL transactions
Zero-downtime migrations, AddIndexConcurrentlyZero-downtime migrations Django migrations
DRF — serializers, viewsets, permissions, throttling, paginationViews and viewsets Serializers Permissions Throttling DRF pagination
Async views, sync_to_async / async_to_syncAsync Django
Why you avoid signals for business logicSignals

🔴 API Design

REST resource modelling, status codesREST principles Status codes PUT vs PATCH
Idempotency keysIdempotency keys Idempotent endpoints Idempotent payments
Pagination — offset vs keyset/cursorVersioning and pagination DRF pagination
Versioning strategiesVersioning and pagination Versioning
Rate limiting algorithms — token bucket, sliding windowRate-limiting algorithms Rate limiter design nginx rate limiting
OpenAPI, typed client generationOpenAPI and typed clients DRF schema
Webhooks — retries, ordering, poison messagesTimeouts and retries Dead-letter queues Transactional outbox
🟢 gRPC / GraphQL — when they beat RESTProtocol comparison gRPC GraphQL

Layer 3 — Data

🔴 PostgreSQL

🔴 pgvector

Distance operators — <->, <=>, <#>, and index/operator matchingpgvector in production Embeddings
HNSW — m, ef_construction, hnsw.ef_searchHNSW and ANN indexes pgvector in production
IVFFlat — lists, ivfflat.probes, build-after-loadpgvector in production HNSW and ANN indexes
Recall vs latency tuningHNSW and ANN indexes Vector databases
Filtered vector search — the recall trapVector databases kNN vector search
Quantization — halfvec, binarypgvector in production Qdrant in production
Hybrid search — tsvector + vector via RRFHybrid search and reranking pgvector in production

🔴 Redis

Data structures beyond strings — sorted sets, hashes, streams, HLLRedis Pub/sub and streams
Cache-aside pattern, TTL + jitterPython patterns Distributed cache
Cache stampede and its fixesCache stampede
Lua scripts for atomicityPython patterns Redis
Pub/sub vs StreamsPub/sub and streams
Distributed locks — and why they’re harder than they lookRedlock critique Advisory locks
Persistence (RDB/AOF), eviction policiesPersistence and memory Clustering and HA

🔴 Celery

Broker vs result backendCelery Broker comparison
acks_late + idempotent tasksCelery idempotency Celery
Visibility timeout and duplicate executionCelery idempotency SQS consumers
Prefetch multiplierCelery RabbitMQ
chain / group / chordCanvas pitfalls
Retries, time limits, DLQ handlingCelery retries Dead-letter queues Exchanges and DLX
Pass IDs, never ORM objectsCelery in interviews Celery idempotency
🟢 Alternatives — arq, Dramatiq, Temporalarq and Dramatiq Temporal vs celery Workflows vs activities

Layer 4 — Cloud & Ops

🔴 AWS

🔴 CI/CD

GitHub Actions — workflows, matrix, caching, OIDC to AWSGitHub Actions Self-hosted runners
Test / lint / typecheck gatesPipeline design patterns CI/CD basics Test data and CI
Container build + push pipelinesPipeline design patterns Secrets and supply chain
Deployment strategies — blue/green, canary, rollingDeployment strategies Progressive delivery
Migration ordering in deploysZero-downtime migrations Deployment strategies

🔴 Observability

Structured logging + correlation IDsStructured logging Correlation IDs
OpenTelemetry — traces, spans, context propagationOpenTelemetry Sampling strategies Jaeger
RED / USE metricsRED and USE metrics Prometheus
Prometheus + Grafana basicsPrometheus Grafana
Alerting on symptoms, not causesSLOs and alerting Choosing a tool
Sentry / error trackingSentry Cost and FinOps

🟢 IaC

Terraform basics — state, modules, plan/applyTerraform state Modules and composition plan and apply
AWS CDK or SAM — for Lambda-heavy stacksCloudFormation vs Terraform CloudFormation

Layer 5 — Frontend (the fullstack claim)

🟡 TypeScript

Interfaces vs types, unions, discriminated unionsNarrowing and guards TypeScript pitfalls
Generics, utility types, unknown vs anyTS generics Utility types Strictness flags
Generating clients from OpenAPIOpenAPI and typed clients REST vs GraphQL vs tRPC

🟡 React

Hooks rules and why they existRules of Hooks Useful hooks
useEffect deps + cleanup, useMemo/useCallbackuseEffectMemoisation heuristics React Compiler
Reconciliation and keyReconciliation The key prop React fiber
Server state (TanStack Query) vs client state (Zustand)Server vs client state TanStack Query Zustand
Consuming SSE / streaming with abortConsuming SSE Abort and races

🟢 Next.js

CSR / SSR / SSG / ISRRendering modes Next.js rendering
App Router, React Server ComponentsReact Server Components RSC in depth App Router layout
Streaming SSR with SuspenseStreaming SSR Suspense for data

Layer 6 — AI / LLM (the differentiator)

🔴 LLM Fundamentals

Tokenization, context windows, token budgetingTokenization Context windows Context management
Temperature, top-p, structured output / JSON modeFunction calling LLM JSON validation The chat API
Function / tool calling mechanicsFunction calling Hallucinations and tools
Prompt caching — and its cost impactGateway and caching KV cache Provider abstraction
Streaming, cancellationThe chat API Streaming modes Server-sent events
RAG vs fine-tuning vs long context — the decision treeFine-tuning vs RAG What RAG solves

🔴 RAG

🔴 Evaluation

Retrieval metrics — recall@k, precision@k, MRR, NDCGAgentic RAG and eval(§ Retrieval metrics)Choosing the metric Recommender systems
Generation metrics — faithfulness, relevance, context precision/recallAgentic RAG and eval(§ End-to-end metrics)Why LLM eval is hard
RAGASEval tooling(§ RAGAS)
LLM-as-judge biases — position, verbosity, self-preferenceLLM-as-judge
Building golden datasets without labelsBuilding eval sets Agentic RAG and eval(§ Build a golden set)
Evals in CI as regression testsBuilding eval sets Eval tooling
Production signals — feedback, abstention rate, score distributionsOnline eval Monitoring and drift

🔴 Agents

🔴 MCP

Tools vs resources vs promptsMCP fundamentals Building a server
Transports — stdio, HTTP/SSEThe stateless-core spec MCP fundamentals
Writing a server (Python SDK)Building a server Securing MCP
Auth for remote serversSecuring MCP The stateless-core spec
Security — tool descriptions are untrusted inputSecuring MCP Prompt injection

🔴 LLM Security & Ops

Prompt injection — direct and indirectPrompt injection Red teaming
Retrieved content is untrusted inputPrompt injection RAG assistant design
PII redaction in / outPII and compliance AI governance
Tool allowlists, spend caps, sandboxingOutput validation Advanced agent patterns Sandboxing agents
Output schema + groundedness validationOutput validation LLM JSON validation
Tracing — Langfuse / LangSmith / OTel GenAITracing platforms LLM observability
Cost attribution, model routing, fallback chainsCost attribution Model routing Provider abstraction

Suggested order

When	Focus	Why
Now	MCP server → RAG eval harness	Small, named gaps, and both produce artifacts
Next	PostgreSQL tuning → pgvector benchmarking	Strongest depth signal, already your stack
Then	Async correctness → FastAPI internals	Asked everywhere, cheap to solidify
Ongoing	Django ORM → Frontend → system design out loud	Breadth maintenance

Keep a decisions.md per project: what you chose, what you rejected, why. Interview stories are hard to manufacture under pressure and trivial to harvest from notes.

Coverage note

Checked 2026-08-21: every theme above resolves to at least one existing note — nothing on this roadmap is uncovered by the corpus. Where a theme lives inside a larger note rather than its own file, the section name is given after the link.