The Best Skills to Put on a Software Engineer Resume

Put the skills that show up in the job description and that you could talk about for ten minutes in an interview. Everything else is noise. For engineers that almost always means specific technologies, not general traits.

Most software engineer resumes need skills from these groups:

• Programming languages: Python, Java, TypeScript, Go, C++, C#, Kotlin, Swift, Rust, SQL
• Frameworks and libraries: React, Next.js, Node.js, Spring Boot, Django, FastAPI, .NET, Rails
• Databases and data stores: PostgreSQL, MySQL, MongoDB, Redis, DynamoDB, Elasticsearch
• Cloud and infrastructure: AWS, GCP, Azure, Docker, Kubernetes, Terraform, Linux
• Delivery and tooling: Git, GitHub Actions, CI/CD, monitoring tools like Datadog or Prometheus
• Testing: pytest, JUnit, Jest, Playwright, Cypress

You do not need every group. A frontend engineer can skip infrastructure. A data engineer probably has no use for a UI framework. Pick the groups that match the job, then pick the specific tools inside each group that you have actually used.

Here is what that looks like on a real resume for a backend engineer with three or four years of experience:

Four lines, about 20 items, and a recruiter can tell in a few seconds what kind of engineer this is. The rest of this guide covers how to build that list for your own role, how to match it to a posting, and what to do with soft skills. If your bullets don't mention these tools yet, fix that too: our software engineer resume bullet points guide shows how.

Hard skills are the teachable, checkable ones: you either know PostgreSQL or you don't, and an interviewer can find out quickly. For a technical resume they are what the skills section is for. This table is a starting list of common examples to pick from, plus what tends to go wrong in each category.

A few hard skills are assumed and rarely worth a slot: Git (unless the posting names it), Microsoft Office, VS Code, Jira, Slack, and "operating systems" as a general claim. They don't hurt much, but they push more useful items further down the line.

For deeper advice on specific technologies, see our guides on listing Python, AWS, Docker, Kubernetes, React and TypeScript.

The best skills list depends heavily on which job you're applying for. These are example skills sections for common engineering roles. Treat them as templates: swap in your own stack and remove anything you haven't used.

The fastest way to find the right skills to put on a resume is to read the posting and copy its vocabulary, limited to what you can honestly claim.

1. Collect three to five postings for the role you want. Highlight every named technology.
2. Count repeats. If PostgreSQL appears in four of five postings and Cassandra in one, PostgreSQL earns the spot.
3. Check the required section first. Required skills you have should all be on the page. Preferred skills are a bonus.
4. Cross off anything you can't defend. If you would struggle to explain how you used it and why, leave it off.
5. Use the posting's spelling. If it says Amazon Web Services, Node.js or CI/CD, write it that way.
6. Repeat the top skills in your bullets. A skill that appears in the list and in an experience bullet reads as real.

Why the spelling matters: many companies run applications through an applicant tracking system (ATS). In Greenhouse, one of the common ones, recruiters can search resumes for keywords and run Boolean queries across candidates. A recruiter searching for Kubernetes is typing that word, so a resume that only says K8s may not come up. Writing the full term once, with the short form in parentheses if you like, covers both: Kubernetes (K8s).

This is also why keyword stuffing backfires. Getting past a search only gets your resume in front of a person, and that person will notice twenty tools with no evidence behind them.

Tailoring doesn't mean rewriting your resume for every application. Most engineers keep one base version per role type (say, backend and platform) and adjust the skills order and two or three bullets per posting.

Group skills into labeled lines

Use three to five lines, each with a short label and a comma-separated list. Labels like Languages, Frameworks, Cloud and infra, Data or Testing are fine. Use whatever split makes your stack obvious. One long paragraph of 30 tools is much harder to scan.

Order by relevance

Put the line the job cares about most at the top, and the strongest item first within each line. For a Go backend role, Go comes before Python even if you've written more Python.

Keep it to what fits in a few lines

There is no correct number. For reference, Simplify counted skills on 75,308 resumes edited on its platform (users skew toward students and early-career technical candidates): the median was 15, the mean was 19.4, and 40% listed more than 20. In practice, 12 to 25 items across three to five lines works for most engineers. If you need a sixth line, some of those items probably don't belong.

Decide where it goes

• Students and new grads: near the top, after education, because skills and projects carry most of the page.
• Experienced engineers: either a short block near the top or at the bottom after experience. In the popular Jake's resume template, Technical Skills sits at the bottom, and that works fine when your experience bullets already name the stack.
• Career changers: near the top, so the reader sees the technical skills before an unrelated job title.

Skip ratings, bars and logos

Star ratings, progress bars and percentages ("Python 90%") mean nothing to a reader and can confuse a parser. Logos and icons often don't come through as text at all. If you want to show depth, split into Proficient and Familiar lines, or let your bullets do it.

Keep the formatting plain

Use a single-column layout with real text, standard section names (Skills or Technical Skills) and the same font as the rest of the page. Our ATS-friendly tech resume template already does this, and the resume format checker will flag layout problems.

Hard skills are specific and checkable: Python, Terraform, SQL query tuning, iOS development. Soft skills are about how you work: communication, collaboration, mentoring, ownership, handling ambiguity.

Both matter to engineering teams, and soft skills carry more weight the more senior the role. The difference is where they go on the page. Writing Communication, Leadership, Team Player in a skills list tells the reader nothing, because every candidate can type those words. A bullet that shows you doing the thing is evidence.

Here is how common soft skills translate into engineering bullets. The numbers are illustrative; use your own.

If a posting leans hard on a soft skill, say "strong written communication" for a remote role, make sure at least one bullet clearly shows it. That covers the reader and the keyword at the same time.

For the full method behind bullets like these, see the XYZ method and our resume bullet generator.

Both stronger versions are shorter, but length isn't the point. Each one tells the reader what job this person is going for, and the leadership and communication claims move into bullets where they can be backed up.

• Anything you couldn't discuss in an interview. If a tutorial is your only experience with it, it doesn't belong in the list.
• Generic soft skills like hardworking, detail-oriented, team player or fast learner. Show them in bullets instead.
• Assumed tools: Microsoft Word, Google Docs, Slack, Zoom, VS Code, and usually Jira.
• Stale tech that points away from the role: jQuery, AngularJS, SVN or Flash on a modern frontend application, unless the posting mentions maintaining them.
• Vague categories: web development, cloud, databases, coding. Name the actual tools.
• Skills added only for ATS that you've never used. You might match a search, but the first technical screen will expose it.
• AI coding assistants as a headline skill. GitHub Copilot or Cursor on their own say little. If you built something with LLMs, list the APIs and techniques (RAG, embeddings, evals) and describe the project.

A shorter, focused list usually reads as more senior. It shows you know what matters for the job.

Recruiters use the skills section to check fit quickly. Hiring managers and interviewers use it differently: they look for each listed skill in your bullets and projects, and ask about it when they find a gap.

A quick check before you send the resume: take your top five or six skills and find each one in an experience or project bullet. If you can't find one, either add a bullet that uses it or move it lower in the list.

If your resume already has the right skills but isn't getting responses, the problem may be the bullets or the layout rather than the keywords. Our guide to what technical recruiters look for and the common resume mistakes list are good next stops.