Python Developer CV & Resume Guide 2026 — Skills, Stack, Bullets & Salary by Domain
Python developer hiring in 2026 is no longer one role — it is five overlapping disciplines (web/API, data engineering, ML/AI, DevOps/platform, automation), each with its own framework stack, vocabulary, and metric language. Your CV is read against the domain you target, so a generic 'Python developer' resume converts at a fraction of the rate of a domain-specialised one. This guide covers responsibilities by domain, the modern Python stack, salary benchmarks, 90+ resume keywords, 16 quantified bullets, and the 8 mistakes that get strong Python CVs filtered out — with cross-links to the bullet examples and skill-cluster pages you'll need to tailor on a per-application basis.
- Declare the domain in the first line — web backend, data engineering, ML, automation and tooling, or scientific computing. Python roles diverge enormously and the framework a team uses is the actual filter.
- Name the frameworks and versions: Django, FastAPI or Flask for web; pandas, Polars, PySpark or Airflow for data; asyncio where it matters. Add the Python version and typing discipline, because typed, modern Python is a real differentiator.
- Show engineering practice: pytest coverage, mypy or pyright, ruff or black, packaging and dependency management (uv, Poetry, pip-tools), and CI. Python resumes that only list libraries read as scripting rather than software engineering.
- Quantify performance or scale work — a job you took from hours to minutes, a query or pipeline you optimised, memory or cost reduced, throughput handled. 'Rewrote the nightly ETL in Polars; runtime 4.2h to 19min' is a complete argument.
- Include the production surface: the database and ORM, caching, task queues (Celery, RQ, Dramatiq), containerisation, and monitoring. Owning Python in production, not just writing it, is what distinguishes the senior band.
Responsibilities
- Design and ship production Python services — APIs (FastAPI / Django REST / Flask), background workers, scheduled jobs, gRPC services — with a documented latency, throughput, and error budget
- Own data models in SQLAlchemy / Django ORM / Pydantic / SQLModel and the migration story (Alembic, Django migrations) for schema changes that ship with zero downtime
- Build and maintain ETL / ELT pipelines (Airflow, Prefect, Dagster, dbt) — including SLA, retry, alerting, lineage, and cost discipline on Snowflake / BigQuery / Redshift / Databricks
- Deliver ML / AI features — training and serving (PyTorch, TensorFlow, scikit-learn, XGBoost), feature stores, MLflow / W&B for tracking, model monitoring for drift
- Integrate LLMs into product flows (LangChain, LlamaIndex, OpenAI, Anthropic, vLLM) — RAG pipelines, agent orchestration, evaluation harnesses, prompt versioning, cost guardrails
- Operate Python services in production — Docker, Kubernetes, ECS/Fargate, Lambda, Cloud Run; observability via OpenTelemetry, Prometheus, Datadog, Sentry; on-call rotation
- Write and maintain test suites — pytest, hypothesis, factory_boy, pytest-asyncio, tox; type checking with mypy / pyright; CI in GitHub Actions / GitLab / CircleCI
- Profile and optimise Python performance — cProfile, py-spy, scalene; switch hot paths to Cython, mypyc, or Rust (PyO3) when justified by a measured bottleneck
- Design async and concurrent systems — asyncio, trio, Celery, RQ, Dramatiq; reason about contention, back-pressure, idempotency, and distributed coordination
- Partner with Data, Product, and Security — define API contracts (OpenAPI / GraphQL), threat-model new endpoints, rotate secrets, and review dependencies via Snyk / Dependabot
- Mentor mid and junior engineers — pair programming, design-review feedback, documentation, RFCs; raise the engineering bar across review and architecture
- Use AI coding tooling responsibly (Cursor, Claude Code, Copilot, Aider) — generate scaffolding and tests, review every diff, and write the architecture-level prompts only humans can
Required skills
- Modern Python — typing, dataclasses, Pydantic, asyncio, context managers, pattern matching, packaging (uv / poetry / hatch)
- Web framework depth — FastAPI, Django + DRF, Flask, Starlette; REST and GraphQL (Strawberry, Ariadne); async I/O patterns
- Data layer — SQLAlchemy 2.x, Django ORM, raw SQL on PostgreSQL / MySQL / Snowflake / BigQuery; query plan reading; pgvector / Vespa / Qdrant for vectors
- Data engineering tooling — Airflow, Prefect, Dagster, dbt, PySpark, Polars, DuckDB; streaming via Kafka, Kinesis, Pulsar
- ML / AI — scikit-learn, PyTorch, TensorFlow, XGBoost; MLflow, W&B; LangChain, LlamaIndex, vLLM, transformers; evaluation and red-teaming
- Cloud and infra — AWS / GCP / Azure; Docker, Kubernetes, Helm, Terraform, Pulumi; serverless (Lambda, Cloud Run); IaC for stateful and stateless services
- Testing and quality — pytest, hypothesis, mypy / pyright, ruff / black, pre-commit; mutation testing; coverage discipline tied to risk, not vanity
- Observability and reliability — OpenTelemetry, Prometheus, Grafana, Datadog, Sentry; SLO / SLI design; chaos and load testing (Locust, k6)
- Performance — profiling, caching (Redis, memcached), bulk operations, batched I/O, Cython / Rust extensions where measured
- Soft skills — RFC writing, design reviews, on-call ownership, mentoring, scoping, partnering with non-engineering stakeholders
Salary range
United States 2026 base bands: Junior Python Developer $90–115K; Mid $115–155K; Senior $155–205K; Staff $205–275K; Principal $275–360K. ML / AI specialists carry +15–30% over generalist Python at every level (Senior ML Engineer $185–245K; Staff ML Engineer $250–340K). FAANG, AI-native and fintech multiply 1.4–2.0x via equity, sign-on, and retention. United Kingdom 2026: Junior £45–60K; Mid £60–85K; Senior £85–120K; Staff £120–165K; Principal £160–220K. Europe (Berlin / Amsterdam) +15–25% over UK; remote-only US bands compress 10–15% versus hub bands.
Typical career path
Junior Python Developer (0–2 yrs) — single service ownership under guidance, scoped tickets, code review participation → Mid Python Developer / Software Engineer II (2–4 yrs) — feature ownership end-to-end, mentor interns, on-call participation → Senior Python Developer / SWE III (4–7 yrs) — system ownership, design docs, cross-team partnership, interview-loop participation → Staff Engineer / Tech Lead (7–10 yrs) — multi-system architecture, RFC author, drives roadmap, no people-management → Principal / Distinguished Engineer (10+ yrs) — org-wide technical direction, deep specialism (ML platform, data platform, infrastructure), industry visibility → Engineering Manager / EM (people track lateral) — 4–8 reports, performance management, hiring, partner with PM and Design → Director of Engineering — manage managers, multi-team budget, cross-org alignment → VP / CTO — engineering org leadership, board-level reporting, technical strategy
Top resume keywords for this job
Python developer CVs in 2026 are read against five overlapping domains — web/API, data engineering, ML/AI, DevOps/platform, and automation. The single biggest mistake on a Python CV is failing to declare which domain you target before the recruiter scans the bullets. A senior backend engineer applying to an ML platform team needs different framing than the same person applying to a Stripe-style API team. Lead with a one-line domain claim under your name and reinforce it through the rest of the document.
Domain framing. Web/API specialists lead with FastAPI / Django and a latency or throughput number on a real production endpoint. Data engineers lead with Airflow / dbt / Spark and a pipeline volume + SLA. ML engineers lead with the model in production, the metric it moved, and the serving stack (vLLM, Ray Serve, FastAPI). DevOps / platform engineers lead with Kubernetes / Terraform / observability and an incident-rate or cost-per-request number. Automation specialists lead with $ saved or hours reclaimed, with the integration surface (Zapier, Workato, custom). The job description tells you which domain to lean into — your CV should explicitly mirror it.
Framework depth, not breadth. Listing twenty libraries without context signals surface familiarity. Pair frameworks with what you shipped — 'Migrated checkout API from Flask to FastAPI; tail latency p99 dropped from 480ms to 110ms at 9k RPS sustained' is worth more than a 'Skills' section listing every tool you've touched. The shape recruiters and engineering-managers look for in 2026: one or two leaned-into specialisations with proof, plus a credible second discipline.
AI fluency is a baseline expectation, not a differentiator on its own. Hiring managers in 2026 assume you use Cursor, Claude Code, or Copilot for scaffolding, tests, and refactors. The interesting signal is whether you have shipped LLM features into production: RAG pipelines with evaluation harnesses, agent orchestration with tool calls, prompt versioning, model cost guardrails, or model-monitoring jobs. If you have shipped any of these, name the eval framework, the cost number, and the user-facing metric they moved. If you haven't, do not pad your CV with chatbot demos — show the engineering signals (test coverage, observability, performance) that translate into the role faster.
Production operations are the senior signal. Junior CVs talk about features. Mid-level CVs talk about systems. Senior, staff, and principal CVs talk about reliability, cost, and team velocity — error-budget management, incident response, on-call rotations, capacity planning, and the architectural decisions that prevented a class of bug. Your CV should match the level you're targeting: at staff and principal, technical depth without operational ownership reads as 'senior IC who hasn't grown'.
Finally, modernise your stack signals. In 2026, recruiters search for FastAPI more than Flask, uv / poetry over pip, ruff over flake8, mypy / pyright over no typing, async over sync, and OpenTelemetry over ad-hoc logging. Listing only the legacy alternatives marks the CV as written in 2018; listing only modern tools without legacy reads as junior. Mix the two with intent — modern primary, legacy where the role still needs it.
Common mistakes to avoid
- Generic 'Python developer' framing with no domain — recruiters can't tell whether you're a backend, data, or ML engineer in the first 6 seconds
- Listing 30+ libraries in a skills section with zero context — reads as tutorial dump, not production experience
- Bullets that name a tool but skip the metric: 'Built APIs with FastAPI' vs 'Built FastAPI service handling 12k RPS at p99 < 90ms'
- Outdated stack signals only — pip + flake8 + Flask in 2026 reads as 2018; mix with uv / ruff / FastAPI to look current
- Padding with AI / LLM buzzwords with no shipped feature — name the RAG pipeline, the eval harness, the user metric, or skip it
- Senior CVs that show feature delivery but no operational signals — error budgets, on-call, cost ownership are required from staff up
- Treating tests as a virtue independent of impact — 'Wrote 95% test coverage' without an incident-rate or velocity number reads as vanity
- Ignoring the JD's specific stack and submitting a generic CV — Python is too broad to win on generic; tailoring is non-optional
Interview tips for this role
- Expect a system-design round even at mid-level — the modal Python interview in 2026 includes 'design a rate-limited API that handles 50k RPS with 99.9% SLO'
- Prepare a 90-second narrative for your most production-impactful Python project, with a metric and a tradeoff you made
- For ML / AI roles, expect an evaluation-and-monitoring question — 'How do you know your RAG pipeline is degrading?' filters surface-level candidates
- Brush up on async patterns (back-pressure, cancellation, structured concurrency) — they come up in mid-and-senior screens more than in 2022
- For platform roles, be ready to walk through a real on-call incident — what alerted, what you ruled out, the fix, the post-mortem action
- If you use AI coding tools daily, be ready to explain how — interviewers in 2026 ask specifically how you review and verify AI-generated code
Frequently asked questions
How long should a Python developer resume be?
One page for 0–7 years of experience; two pages from staff onwards. Senior Python engineers regularly try to fit a full career on one page and end up with 9pt font and three-letter abbreviations — recruiters skip those. Cut anything older than 12 years, anything you would not want to be interviewed on, and anything that does not signal the domain you target.
Should I list every Python library I have used?
No. List the ones you've used in production at the level the role expects. A skills section that names FastAPI, Pydantic, SQLAlchemy, asyncio, pytest, mypy, OpenTelemetry, and Docker reads as senior. The same skills section plus 30 micro-libraries reads as a tutorial dump. Recruiters and ATS both reward focus.
How should I write Python bullets if I switched domains?
Lead with the new domain on the most recent role, then translate older domain experience into the framing of the new one. A backend engineer pivoting to ML should write older API bullets in 'systems / latency / availability' framing rather than feature framing — both translate to ML platform work, but only one signals it.
Do I need to mention AI coding tools (Cursor, Claude Code, Copilot)?
Mention them once if you genuinely use them daily, ideally with the engineering result they enabled — 'Authored production code with Cursor + MCP-backed test loop, increasing PR throughput 1.6x without raising defect rate.' Listing them as standalone skills with no context reads as buzzword stuffing in 2026.
What metrics matter most on a Python developer resume?
Throughput (RPS, msgs/sec, rows/sec), latency (p50/p95/p99), reliability (error-rate, SLO attainment, MTTR), cost (per-request, per-pipeline, per-inference), scope (data volume, user count, $ business impact), and quality (test coverage if it's tied to incident reduction, not vanity). Two metrics per bullet beats five.
Should I include open-source contributions?
Yes if (a) the project is recognisable to engineers in your target domain and (b) the contribution is substantive — a meaningful PR, a sustained maintainer role, a popular package you authored. Drive-by typo fixes and starred repos do not belong on a CV. Link the GitHub profile in the header rather than padding bullets.
Is Django still worth featuring vs FastAPI in 2026?
Yes — Django still powers a huge share of Python production, especially in marketplaces, admin-heavy SaaS, and government/enterprise. List both honestly. Lead with what the target role uses: if the JD names FastAPI, lead with FastAPI; if it names Django, lead with Django. Do not de-emphasise Django on principle — it remains highly hireable.
How do I differentiate from offshore / agency Python CVs that look similar?
Specificity. Offshore CVs often list every framework and every cloud, with no metric on any line. Beat them with named systems, numbers, and outcomes — 'Owned the billing-events pipeline (Kafka → Airflow → Snowflake, 4B events/day, 99.95% SLA, $11K/mo cloud spend)' is unfakeable in a way 'Worked on data pipelines using Kafka, Airflow, Snowflake' is not.
Related guides
Explore more guides
- Best AI Resume Builders 2026
- CV vs Resume Guide
- How to Humanize Your AI Resume
- GEO for Resumes: 8 Rules for AI Screeners
- AI Recruiter Tools 2026: 14 LLM-Based Platforms
- Free CV Builder for UK Jobs