WadeCV

Software Engineer Resume Skills (2026) — 60+ Stack Examples by Domain & Level

Software engineer hiring in 2026 is decided in the first six seconds — recruiters scan the top of the CV for domain, seniority, and a stack vocabulary that matches the JD. A skills section that lists 'JavaScript, Python, AWS' alongside 25 micro-libraries reads as junior; a focused, opinionated set of clusters with named systems reads as senior. This guide gives you the six skill clusters that show up in 2026 SWE JDs (Backend / API, Frontend / UX, Data & ML, Platform / DevOps, AI-engineering, Quality & reliability), 60+ named stack items, 12 quantified bullet examples mapped to seniority, AI-coding fluency framing, and the eight common mistakes that get strong SWE CVs filtered out.

  • Languages & runtimes — Python (FastAPI, Django, asyncio), Node/TypeScript (NestJS, Fastify, tRPC), Go, Java/Kotlin (Spring Boot), Rust (Axum, Actix), C# (.NET 9)
  • API surfaces — REST, GraphQL (Apollo, Strawberry), gRPC, OpenAPI / contract testing, server-sent events, WebSockets
  • Data layer — PostgreSQL, MySQL, MongoDB, DynamoDB; ORMs (SQLAlchemy 2.x, Prisma, TypeORM, GORM); query plan reading, index design, partitioning
  • Caching & messaging — Redis, Memcached, Kafka, Kinesis, Pulsar, NATS, RabbitMQ, AWS SQS / SNS
  • Reliability patterns — idempotency, outbox, sagas, circuit breakers, rate limiting, retries with backoff, exponential SLOs
  • Auth & security — OAuth 2.0 / OIDC, JWT, mTLS, secrets management (Vault, AWS KMS), threat modelling

  • Frameworks — React 19, Next.js 16 (App Router, Server Components), Remix, Vue 3, Svelte/SvelteKit, Solid, Qwik
  • Tooling — Vite, Turbopack, esbuild, SWC, TypeScript 5.x; pnpm / bun / yarn 4
  • Styling & UI — Tailwind 4, shadcn/ui, Radix, CSS-in-JS (Stitches, Vanilla Extract), design tokens, motion (Framer Motion)
  • State & data — TanStack Query, Zustand, Redux Toolkit, Jotai, Effector; SWR; URL-as-state
  • Performance — Core Web Vitals, RUM, code splitting, image optimisation, edge rendering, streaming SSR
  • Accessibility & i18n — WCAG 2.2, aria, keyboard flows, screen-reader testing, ICU MessageFormat, RTL support

  • Storage & compute — Snowflake, BigQuery, Redshift, Databricks, DuckDB, ClickHouse
  • Pipelines — Airflow, Prefect, Dagster, dbt, Polars, PySpark, Beam
  • ML toolkit — PyTorch, TensorFlow, scikit-learn, XGBoost, Hugging Face Transformers, MLflow, Weights & Biases
  • Streaming — Kafka, Flink, Spark Structured Streaming, Materialize
  • Quality & lineage — Monte Carlo, Great Expectations, soda, OpenLineage, DataHub
  • Vector / retrieval — pgvector, Qdrant, Pinecone, Weaviate, FAISS

  • Containers & orchestration — Docker, Kubernetes, Helm, Argo CD, Tekton, Knative
  • IaC — Terraform, Pulumi, CDK (AWS / cdk8s), Ansible
  • Cloud — AWS (Lambda, ECS, Fargate, EKS, S3), GCP (Cloud Run, GKE, BigQuery), Azure (AKS, Functions)
  • CI/CD — GitHub Actions, GitLab CI, CircleCI, Buildkite, Drone; Bazel for monorepos
  • Observability — OpenTelemetry, Prometheus, Grafana, Datadog, Sentry, Honeycomb
  • Reliability — SLO/SLI design, error budgets, chaos testing (Gremlin, Litmus), incident command, post-mortems

  • LLM platforms — OpenAI, Anthropic, Google, Mistral, Cohere; vLLM, llama.cpp, Ollama for self-hosted
  • Frameworks — LangChain, LlamaIndex, DSPy, Semantic Kernel, Guidance
  • Retrieval & memory — pgvector, Qdrant, Pinecone, hybrid retrieval, semantic chunking, ColBERT
  • Agentic patterns — tool calling, MCP servers, ReAct, multi-agent orchestration, planner-executor
  • Eval & monitoring — Llama-as-judge, Ragas, Promptfoo, Langfuse, Helicone; cost-and-quality dashboards
  • Coding-with-AI fluency — Cursor, Claude Code, GitHub Copilot, Aider, code-review-of-AI rubrics

  • Testing — pytest, jest, vitest, playwright, cypress; hypothesis / fast-check; mutation testing (Stryker, mutmut)
  • Type systems — TypeScript strict mode, mypy / pyright, Sorbet, Flow; typed schemas (Zod, Pydantic)
  • Code quality — ruff, eslint, biome, sonarqube; pre-commit hooks; renovate / dependabot
  • Architecture — RFCs, ADRs, design reviews, capacity planning, cost reviews
  • Collaboration — async writing, PR review, mentoring, on-call ownership, post-mortem authoring
  • Influence — cross-team RFCs, internal talks, hiring loop participation, interviewer training

Resume bullet examples

  • Junior Software Engineer — Shipped 12 React + tRPC features behind feature flags for a 320k-WAU dashboard; reduced new-feature time-to-launch from 3 weeks to 4 days through reusable shadcn/ui components and TanStack Query patterns.
  • Mid Software Engineer — Owned the orders service (FastAPI, Postgres, Redis, Kafka outbox) processing 4.2M events/day at 99.96% SLA; eliminated the duplicate-order incident class that had cost ~$22K/month in refunds.
  • Mid Frontend Engineer — Migrated the marketing site from Pages Router to Next.js 16 App Router + Server Components; cut LCP from 3.4s → 0.9s, raised conversion +12%, and shaved 41% off bundle size by removing client-side data fetching.
  • Senior Backend Engineer — Re-architected the pricing API (Go → Python FastAPI + asyncpg) to handle 9.2k RPS at p99 < 110ms — 4.3x throughput at 38% lower CPU spend, with the new service authoring the org-wide async-Python guidelines.
  • Senior Frontend Engineer — Led the design-system migration to Tailwind 4 + shadcn/ui across 6 apps and 1,400 components; reduced visual-regression incidents -84% and dropped weekly design-review time from 9 hrs to 2 hrs.
  • Senior Full-Stack Engineer — Owned the AI copilot product (Next.js, FastAPI, LangChain, pgvector, OpenAI + Anthropic) for 22k internal users; reduced support-resolution time -34%, with cost-per-call $0.0011 thanks to caching + routing.
  • Senior Data / ML Platform Engineer — Built the company's feature store (Feast + BigQuery + Redis); training-vs-serving skew incidents 7/quarter → 0 in two consecutive quarters, and per-model engineering time fell from 5 days to 4 hours.
  • Senior DevOps / Platform Engineer — Authored the internal-developer-platform CLI (Pulumi + Argo Workflows) that provisions a fully-observed FastAPI service in 4 minutes (was 3 days); cut new-service onboarding cost from 14 eng-days to 0.5 eng-days.
  • Staff Engineer (Backend) — Drove the org-wide migration off pip / poetry to uv across 38 services; cumulative CI time saved 41 hrs/day, image rebuilds 3.2x faster, and the lockfile policy was adopted as the standard across two acquired teams.
  • Staff Engineer (AI features) — Designed the company's LLM-eval harness (Promptfoo + Langfuse + Llama-as-judge); shipped guardrails on 14 surfaces, prevented 9 prompt regressions in production, and wrote the reviewed-AI-code rubric now used at PR-level.
  • Principal Engineer (Reliability) — Reduced the highest-traffic-tier monthly customer-impacting incident count 9 → 1 by introducing error-budget-driven release gates, capacity-planning RFCs, and a chaos-engineering programme; saved an estimated $4.1M in churn-and-refunds.
  • Engineering Manager (people track) — Manage 7 ICs across two squads (backend + frontend); raised median PR cycle-time from 31h to 9h via lightweight async review SLAs, and grew two ICs from Mid → Senior with documented promotion packets in the same year.
Get these skills onto your resume in the recruiter's language

Paste a job URL and your background into WadeCV. It maps your real experience against the posting, mirrors the exact skill keywords the ATS screens for, and writes quantified, recruiter-ready bullets — ATS-safe DOCX, free to try with 1 credit included.

Software engineer skills sections in 2026 should be opinionated, focused, and structured around the domain you target rather than the breadth of every tool you've touched. Recruiters at top companies see 200+ CVs per req — they reward signal-density and penalise tool-list dumps.

Lead with your domain. The first cluster on your skills section should declare which lane you fight in: Backend / API, Frontend / UX, Data & ML, Platform / DevOps, AI-engineering, or Embedded / Systems. A senior backend engineer applying to a platform team should reorder their clusters so platform leads, not bury it third. The cluster ordering itself is a signal.

Name modern, named systems. 'JavaScript' is weaker than 'TypeScript 5 + Next.js 16 App Router + tRPC + TanStack Query'. 'AWS' is weaker than 'Lambda, ECS Fargate, EKS, S3, DynamoDB; CDK + Terraform for IaC'. Recruiter searches and ATS keyword filters in 2026 lean heavily on specific tool names — be specific.

Match the level expected. Junior CVs show language and framework fluency. Mid CVs show production systems with metrics. Senior CVs show systems design, reliability ownership, and team patterns. Staff CVs show org-wide migrations and authored RFCs. Principal CVs show technical strategy that survived a real bet. EM CVs show people growth, hiring, and cross-team alignment.

AI-engineering is now a baseline cluster, not a flavour. Even if you do not work primarily on LLM features, recruiters in 2026 expect a sentence on AI-coding fluency (Cursor / Claude Code / Copilot) and an opinion on RAG vs fine-tuning vs agentic patterns. The signal is not 'I use AI tools' — it's 'I have a thoughtful position and a reviewed-AI-code rubric'.

Quality and reliability are differentiators at senior level. Most CVs name pytest or jest. Far fewer name SLOs, error budgets, mutation testing, contract tests, or post-mortem authoring. The skills that name those signals get pulled out of the pile.

Cross-link from skills to bullets. Every named tool in your skills section should appear in at least one bullet that proves production usage. Tools that exist only in skills read as 'I read about it once'. The cleanest CVs map skills 1:1 to bullets — recruiters can audit them in seconds.

Finally, modernise the vocabulary. In 2026, recruiters search for FastAPI more than Flask, TypeScript over JavaScript, Next.js App Router over Pages Router, uv over pip, ruff over flake8, OpenTelemetry over ad-hoc logging, vLLM / Ollama / Anthropic / OpenAI over generic 'AI'. Lead with current; mention legacy where the role still uses it.

Tailor your resume to highlight the right skills

Paste a job URL and WadeCV matches your skills to what the employer wants — then rewrites your bullets to prove each one.

  • 1 free credit on signup
  • AI-powered fit analysis
  • ATS-optimised formatting

Common mistakes to avoid

  • Listing 60+ tools in a skills section — reads as tutorial dump and ATS rankers penalise density
  • Domain-less framing ('Software Engineer with experience in many technologies') — recruiters can't tell whether you fit the role in 6 seconds
  • Skills that don't appear in any bullet — recruiters audit this and treat orphan skills as 'read about once'
  • Listing legacy stack only (Flask, jQuery, on-prem) — modernise to FastAPI / Next / cloud to look current
  • Self-claimed soft skills ('Communication, Leadership') without bullet evidence — looks like padding
  • AI-engineering cluster missing entirely on senior CVs — even if you don't ship LLM features, name your AI-coding workflow
  • Mid + senior CVs that show only feature delivery, no reliability / cost / team-velocity signals
  • Frontend CVs that omit Core Web Vitals, accessibility, and bundle-size signals — recruiters in 2026 expect them

Frequently asked questions

  • How many tools should I list in a software engineer skills section?

    Aim for 6 focused clusters with 4–6 named items each — total 24–36 named tools. Beyond 40, the section reads as a tutorial dump. Beyond 60, ATS rankers actually penalise the density. Be opinionated.

  • Should I list languages I worked in once or only ones I'm productive in?

    List only ones you would be comfortable writing a take-home in. A 'Languages: Python, JS, Go, Rust, Java, C#, Ruby' line where you've shipped two of them invites embarrassment in screens. Recruiters and engineers can usually tell which ones are real.

  • Where should I put AI-coding tools (Cursor, Claude Code, Copilot)?

    Inside the AI-engineering cluster, with a brief result-oriented note. The strongest signal is showing you have a position on reviewed-AI-code workflows, not just listing the IDEs.

  • How do I structure skills if I switched specialisms (e.g. backend → ML)?

    Lead with the new specialism's cluster and put the prior specialism second. Keep both fully-fleshed — you're more hireable as a 'backend engineer with two years of credible ML production work' than as 'ML engineer with no backend listed'.

  • Do I need a separate 'Soft skills' section?

    No — modern engineering recruiters look for soft-skill signals in your bullets (mentoring, RFCs, on-call, hiring participation) rather than self-claimed adjectives. A separate 'Communication, Leadership, Teamwork' section reads as filler.

  • Is it worth listing certifications (AWS, GCP, Kubernetes)?

    Worth listing for early-career and DevOps / platform roles where the cert maps directly to JD vocabulary. Less useful at senior+ level — your bullets should already prove you can operate the platform. Never let certifications outrank shipped systems on the page.

  • How often should I refresh my skills section?

    Whenever the JD vocabulary you're targeting shifts — typically every 6–12 months. The 2024 → 2026 shift required adding AI-engineering, async-Python, App Router, MCP, and observability tooling to most senior CVs. Keep one master CV updated continuously.

  • What stack vocabulary feels dated in 2026?

    Listing only Flask (not FastAPI), only jQuery (not React/Next/Svelte), only Bash (without Python or Go), only on-prem with no cloud, only synchronous APIs, only ad-hoc logging without OpenTelemetry, and 'AI' as a single skill without a named platform. None are deal-breakers in isolation, but a stack of all of them ages the CV by 5 years instantly.

Related guides

Explore more guides

Compare AI resume tools

Build a resume that highlights these skills

WadeCV helps you tailor your CV to the role and surface the right skills and bullets for each application.