Python Developer Resume
Skills & ATS Keywords

The foundation. Name the language version outright (Python 3.11 or 3.12) and show you write modern, well-typed Python: type hints on every signature, dataclasses or attrs over hand-rolled classes, async-await on the I/O paths, structural pattern matching where it earned its seat, generators and context managers, slots when memory matters, and a sober view of the GIL. The way you talk about __init__, __slots__, and dunder methods reads as the line between someone who has shipped Python and someone who watched a tutorial.

Python 3.12, type hints, dataclasses, async-await, pattern matching, generators, context managers, slots, memoryview

The contract the rest of the org talks to. FastAPI on greenfield service work, Django on the bulk of admin-heavy products, Flask on lightweight internal tools. Starlette and ASGI sit underneath when you owned the runtime. Pydantic v2 is the validation default on FastAPI services; REST still dominates, GraphQL via Strawberry shows up on consumer scaleups, WebSockets when the product asked for it.

FastAPI, Django, Flask, Starlette, ASGI, Pydantic v2, REST, GraphQL (Strawberry), WebSockets, OpenAPI

How your service holds and queries state. SQLAlchemy 2.x with the new typed Mapped style is the modern default on FastAPI services; Alembic runs the migrations. The Django ORM ships on a big slice of teams; Tortoise turns up on async Django-shaped work. asyncpg and psycopg sit beneath when you wrote a query layer by hand. Redis on the cache and queue side, MongoDB via motor for async, pgvector on the embedding-search teams.

SQLAlchemy 2.x, Alembic, Django ORM, Tortoise, asyncpg, psycopg, Redis, MongoDB (motor), pgvector

Where a lot of the senior signal sits on a Python resume. asyncio is the baseline; the differentiator is which patterns you actually shipped, asyncio.TaskGroup for structured concurrency, anyio for portable async code, aiohttp or httpx on async HTTP clients, async generators on streaming paths. Multiprocessing for CPU-bound work; threading where I/O dominates; a clear-eyed take on when async stops paying its way around the GIL.

asyncio, asyncio.TaskGroup, anyio, aiohttp, httpx async, async generators, multiprocessing, threading, GIL trade-offs

Name your test stack and the quality gate. pytest with fixtures and parametrize is the baseline; pytest-asyncio for async services, hypothesis on parsers and protocol code, factory-boy on ORM-backed tests, coverage on the gate. mypy or pyright in strict mode reads as the line between a modern Python team and a team that types as decoration. ruff plus black covers the formatter and lint story; mutmut on the critical modules when the team takes the quality bar seriously.

pytest, fixtures, parametrize, pytest-asyncio, hypothesis, factory-boy, coverage, mypy strict, ruff, black, mutmut

Show the file you actually use. pyproject.toml is the modern entry point; hatch and poetry both still ship on real teams; uv has eaten a lot of the new-project share thanks to install speed. pip-tools for lockfile discipline on shops that did not move yet, wheels for the artifact, Docker on a slim or distroless base for the deploy, multi-stage builds to keep the image lean, and a separation of dev versus prod dependencies that survives a deployment review.

pyproject.toml, uv, hatch, Poetry, pip-tools, wheel, Docker, multi-stage builds, lockfiles, dev/prod deps

How the service actually runs in production. Celery on the legacy worker tier, arq or Dramatiq on async-native services, RQ on lightweight queues, APScheduler when the team needed cron inside the process. Kafka via confluent-kafka on the data-platform side. AWS Lambda with Powertools on event-driven and serverless work; GCP Cloud Run when the team wanted containers without the EKS lift. OpenTelemetry-Python on the trace layer.

Celery, arq, Dramatiq, RQ, APScheduler, Kafka (confluent-kafka), AWS Lambda + Powertools, GCP Cloud Run, OpenTelemetry-Python

The lines that lift a Python file at Senior bands. cProfile for the baseline, py-spy for the sampling profile without restarting the process, scalene when CPU and memory matter together, memory_profiler on the leak hunt. Sentry on the exception layer, structlog for structured logs, prometheus_client for the metrics, and a clear take on where the GIL stops you and where you crossed the C-extension boundary on purpose.

cProfile, py-spy, scalene, memory_profiler, Sentry, structlog, prometheus_client, GIL awareness, C-extension boundary