Python · Section 51
What a 5-Year Python Engineer Should Be Able to Explain
A recap section, explicitly framed by the roadmap as questions to explain "without memorized definitions". Forty of its fifty roadmap lines are already taught in depth by other Python sections — closures, LEGB, late binding, decorators, the MRO and super(), descriptors, __slots__, garbage collection, reference counting, the GIL, WSGI versus ASGI, idempotency — and are credited here via alsoCovers rather than re-derived. Ten concepts fill the questions with no existing home: how Python actually passes arguments, choosing a concurrency model for one real workload, the full request-lifecycle hop list, what an index is and when it hurts, what a transaction is and what isolation means, what causes a database deadlock, a fixed slow-query diagnostic checklist, the SQL versus NoSQL decision, when Redis earns its place, and what makes a Python service horizontally scalable. The six database answers live here rather than in the PostgreSQL and MongoDB topics because coverage is computed per topic and Python's own Databases section was removed from scope — those topics own the mechanics and are linked throughout.
- PythonSeventeen of eighteen roadmap questions here are already taught in depth by existing concepts (mutability, is vs ==, default arguments, LEGB, closures, late binding, decorators, iterators/generators, context managers, MRO/super(), descriptors, __getattribute__, __slots__, garbage collection, reference counting) — credited via alsoCovers rather than re-derived. The one genuine synthesis gap, how Python actually passes objects to functions, gets its own concept: one binding rule, not two calling conventions.1 standard1 concept
- ConcurrencyAll eight roadmap questions here are already taught in depth by the Concurrency and Parallelism and Async Python sections (threading vs multiprocessing, the GIL, CPU-bound vs I/O-bound, race conditions and deadlocks, the event loop, blocking code in async apps) — credited via alsoCovers. The genuinely new ground is the synthesis a 5-year engineer is actually asked for: given one real workload, choose a model and justify it in one paragraph.1 standard1 concept
- BackendSeven of eight roadmap questions here are already taught in depth by the ASGI/WSGI/Uvicorn/Gunicorn and API Reliability sections (WSGI vs ASGI, Gunicorn/Uvicorn, connection pooling, timeouts, retries, idempotency, rate limiting) — credited via alsoCovers. The one genuine synthesis gap is naming every hop a request crosses, in order, before application code ever runs.1 standard1 concept
- DatabaseAll eight roadmap questions in this subheading are answered here. The PostgreSQL and MongoDB topics teach the mechanics far more deeply, and are linked throughout — but coverage is computed per topic against that topic's own roadmap (validate-content.js check 11), so a PostgreSQL concept cannot credit a line in the Python roadmap the way an earlier draft of this file assumed. Python's own §25 Databases was removed from scope (CONTENT_REMOVAL.md), which leaves no other home for them. So each is authored here as what a Python engineer must be able to explain — the decision and the failure it prevents — pointing at the owning topic for the depth rather than re-deriving it.3 core3 standard6 concepts
- ArchitectureSeven of eight roadmap questions here are already taught in depth by the System Design topic (monolith vs microservices, when not to split, sync vs async communication, eventual consistency, idempotency, retry-induced duplicates, queue-based worker systems) — credited via alsoCovers on those System Design concepts. The Python-specific framing of the last question (making a Python service horizontally scalable) draws together statelessness, the Gunicorn/Uvicorn worker model, and avoiding hidden global dependencies into one synthesis concept, since no single existing concept states that combination at the Python-process level.1 standard1 concept