FeaturesHow it worksPricing
Resume writing

How to write the skills section of a software engineer resume

· 7 min read

A software engineer's skills section should be four or five labeled lines, grouped the way the target job describes its stack, with the most relevant group first. List only technologies you could answer interview questions on, and mark the few you know lightly as "(basic)". Leave out proficiency ratings, soft skills and tools every engineer uses.

This post covers the skills section itself: what qualifies, how to order it for each application, and a layout for five roles. Whether technologies also belong in your bullets or under each job is covered in tech stack on a resume.

What to put in a software engineer skills section

We assume anything on the page can come up in an interview. So list only what you could talk about for a few minutes, including a decision you made with it or a way it failed you.

Sort every technology you have touched into one of these groups:

  1. You could be interviewed on it. You used it in real work or a serious project and could explain why you used it the way you did. It goes in the list.
  2. You used it, but not deeply. You wrote a few Terraform modules from a template, or fixed bugs in a Python service someone else owned. List it with "(basic)" after it, which tells the interviewer to expect basic questions. Or mention it only in the bullet where you used it.
  3. You have only seen it. A weekend tutorial, a course module, a tool your team used that you never opened. Leave it out.

Our junior software engineer resume example uses the second group. The intern marks two tools "(basic)" in their full skills section:

Programming Languages: Java (Spring Boot), Python (3.x)
Databases: SQLite, PostgreSQL (basic)
Testing: JUnit, Mockito, pytest
Tools & Workflow: Git, Docker (basic), Heroku, Linux
Junior Software Engineer Resume Example
Resume example

Junior Software Engineer Resume Example

"(basic)" marks the tools the intern used but could not go deep on.

View the full example

Harder cases:

  • Your team used it and you did not. The platform team ran Kafka, and you published events through a client library they wrote. Say that in a bullet ("Published order events to the platform team's Kafka cluster") and keep Kafka out of the list unless you can discuss partitions and consumer groups.
  • You used it years ago. Keep it if the job asks for it and you could still discuss it, placed last in its group. Otherwise drop it. Our post on writing a resume with a legacy tech stack covers the case where most of your experience is older technology.
  • You are learning it now, or learned it on your own. If you built something real with it, describe that in a Projects section first. Add it to the skills list only when it passes the interview test. An ad that asks for Rust is not a reason to list Rust after one tutorial.

Group and order the section for the job you want

Use four or five groups and name them the way engineers in that job talk about their stack: Languages, Frontend, Backend, Data, Cloud, Infrastructure, Testing, Mobile. A single group called "Technical skills" or "Other" gives the reader nothing to scan by.

Put the group the job is about first. Inside each group, put what the ad asks for first, then your strongest tools. We recommend reordering for every application. The facts stay the same; only the order and the emphasis move.

A backend engineer applying to a payments role that asks for Go, PostgreSQL and Kafka:

Backend: Go, PostgreSQL, Kafka, Redis
Cloud: AWS (ECS, RDS, SQS), Terraform, Docker
Observability: Prometheus, Grafana, OpenTelemetry
Testing: testify, Testcontainers, k6
Frontend: TypeScript, React (basic)

The same engineer applying to a platform team that asks for Terraform, observability and Kubernetes:

Infrastructure: AWS (ECS, RDS, SQS), Terraform, Docker
Observability: OpenTelemetry, Prometheus, Grafana
Backend: Go, PostgreSQL, Kafka, Redis
Testing: testify, Testcontainers, k6

Infrastructure moved to the top and took a name the platform ad uses. The frontend line is gone, because a platform team will not weigh it and the space is better spent elsewhere. Kubernetes is still missing. This engineer has only deployed to ECS, so they write about ECS in the bullets and prepare to talk about the gap.

Use the spelling the ad uses for tools you really know. If it says "Golang" or "Postgres", a recruiter searching a candidate database may type exactly that. Our senior backend engineer resume example covers both spellings by writing "Go (Golang)".

Keep the format plain: one line per group, the label, a colon, then items separated by commas. Skill "chips" laid out in a grid or a narrow sidebar column can come out in a different order when software extracts the text.

Leave out proficiency ratings, including the word versions

Skill bars and star ratings have no shared scale and do not survive text extraction; the tech stack post covers them. Word ratings fail in the same way. "Expert" and "Intermediate" mean whatever the writer meant, and "Expert" invites the hardest question an interviewer has.

Years per skill ("React, 5 years") look more objective. Your dated roles already show them, though, and the reader cannot check the number against anything else on the page.

Before:
React (Expert), TypeScript (Expert), GraphQL (Advanced), Node.js (Intermediate), Rust (Beginner)

After:
Frontend: React, TypeScript, GraphQL
Backend: Node.js (basic)

Rust is gone. "Beginner" usually means it fails the interview test.

Spoken languages are the exception, because a shared scale exists. Put them in their own short section called "Spoken languages", so they are not confused with programming languages, and use CEFR levels (A1 to C2) or plain words such as "native" and "fluent". Many roles in Europe ask for a second language, so we recommend listing it whenever you have one.

Leave soft skills out of the skills section

"Leadership" and "Communication" take space in a list that readers scan for technology names. Show them in a bullet, where they have an object and a size.

Before:
Soft skills: Leadership, Communication, Mentoring, Teamwork

After:
- Mentored 3 junior developers on React patterns and code reviews
- Wrote the design doc for moving invoice generation to a queue and reviewed it with the billing and data teams

The first bullet is from our mid-level full stack engineer resume example. The second is invented.

Agile and Scrum go the same way. If your process work was real, write it as a bullet, such as "Ran sprint planning for a team of six after the engineering manager left".

Some practices sound soft but are technical skills with a defined method, and they can stay. "Accessibility (WCAG 2.1 AA)" on a frontend resume and "Threat modeling (STRIDE)" on a security resume both pass the interview test.

Do you list Git, Jira and other everyday tools?

We leave them out from mid level on. Git, Jira, Slack and VS Code are on almost every engineer's machine, and they push the tools that differ between candidates further down the line. For a junior with a short list, Git in a tools line does no harm, as the junior example above shows.

List a common tool when the job is about the tool itself. GitHub Actions or GitLab CI belongs on a DevOps resume because building pipelines is the work. Linux belongs there when you administer servers, not when you only use a terminal.

Example skills sections by role

Reorder any of these for the ad in front of you. Labels quoted from our examples keep their original "&".

Frontend. Lead with the language and framework, then state, styling and testing. Add accessibility or performance only if you have done real work on them.

Frontend: TypeScript, Angular, RxJS, NgRx
Styling: SCSS, Angular Material, Storybook
Testing: Jest, Cypress
Accessibility and performance: WCAG 2.1 AA, axe, Lighthouse

Backend. Lead with the language and framework, then data stores and messaging, then where it runs.

Languages and frameworks: Java 21, Kotlin, Spring Boot
Data and messaging: PostgreSQL, Redis, Kafka
Cloud: AWS (EKS, RDS, MSK), Terraform
Testing: JUnit 5, Testcontainers, Gatling

Full stack. One line per layer, with the layer the job leads on first. This is the full section from our mid-level full stack engineer example, whose current role is mostly React and Node.js work:

Frontend: React, Redux, TypeScript, Styled Components, Material UI
Backend: Node.js, Express, TypeScript, REST API Design
Database: PostgreSQL, Prisma, Knex.js
Testing: Jest, Cypress, React Testing Library
DevOps & Tooling: Docker, GitHub Actions, AWS (EC2, S3)
Mid-Level Full Stack Engineer Resume Example
Resume example

Mid-Level Full Stack Engineer Resume Example

One line per layer, with specific AWS services named.

View the full example

If this were your resume, we would make one change: list TypeScript once, in a Languages line or under Frontend. A repeated item costs a slot. For a backend-heavy full stack job, move the Backend and Database lines above Frontend.

DevOps. Name the cloud services, and be honest about the platforms you know less well. Our mid-level DevOps engineer resume example does both:

Cloud Platforms: AWS (ECS, EC2, S3, Lambda), IAM & networking
Containers & Orchestration: Docker, ECS, Kubernetes (basic)
CI/CD & Automation: Jenkins, GitHub Actions, Terraform, Ansible
Monitoring & Logging: Prometheus, Grafana, AWS CloudWatch
Languages & Scripting: Python, Bash

"Kubernetes (basic)" matters because many DevOps ads ask for Kubernetes. The reader sees the gap at once, and the experience section shows the migration of 11 applications to ECS instead.

iOS. Show which UI frameworks you use, because SwiftUI and UIKit experience are not interchangeable, and name the tools you use to test and release.

Languages: Swift, Objective-C (basic)
UI: SwiftUI, UIKit
Architecture and data: MVVM, Swift Concurrency, Core Data
Testing and release: XCTest, Fastlane, Xcode Cloud

Put it into practice

Build your resume in Filiz and watch the PDF update as you edit. Start from scratch, import your current resume, or begin with an example. No sign-up needed to try it.

Create your resumeBrowse resume examples

Frequently asked questions

How many skills should I list?

Four or five groups of three to eight items, so usually somewhere between 15 and 30. A junior engineer often has fewer, and that is fine. Past that range, the reader cannot tell which tools are your main ones, and every extra item is one more thing you can be asked about.

Should programming languages be ordered by proficiency?

Order them by relevance to the job first, then by how well you know them. If the ad is for a Go role and Go is your second-best language, put Go first anyway, as long as it passes the interview test. Never put a language first that you could not defend in a technical interview.

Where do certifications go?

In their own short "Certifications" section with the year, such as "AWS Certified Solutions Architect – Associate, 2024". Do not mix them into the skills lines. If a certification matters for the job, the tool it covers should also appear in your skills and, ideally, in a bullet that shows you used it.

Should I copy the skills from the job description?

Use the ad's spelling for tools you really know, such as "Postgres" instead of "PostgreSQL". Do not add a technology because the ad mentions it. If you lack something the job requires, show the closest real experience in your bullets and expect to discuss it.

Resume examples

Senior Backend Engineer Resume Example
Senior

Backend Engineer

Senior Backend Engineer Resume Example

Keep reading

Software engineer resume bullet points: a formula and examples by role

Write each bullet as what you did, to which system, with what result, and adapt the pattern for frontend, backend, iOS, DevOps and fintech work, including work with no metric.

Keep reading

Structured resumes for software engineers.

Product
  • Features
  • Pricing
  • How it works
  • Templates
  • Examples
  • Blog
© 2026 FilizFiliz is a product of Grycode Ltd (Company No. 12264904), registered in England & Wales.Registered office: Office 408 Screenworks, 22 Highbury Grove, London N5 2ER, United Kingdom.