Software engineering résumés follow different rules than general professional résumés. The audience has more technical literacy, the screening is often a hybrid of automated tooling and a senior engineer scanning in thirty seconds, and the signal-to-noise ratio is brutal. This guide covers what to include, what to cut, and how to tune the document by level.

The One-Page Rule Still Applies

Unless you have 10+ years of experience and a highly varied background, keep the résumé to one page. A staff engineer with 15 years at four companies can justify 1.5 pages. A senior engineer at two companies cannot.

The page constraint forces ruthlessness. Every bullet competes for space. Every filler word must defend its existence.

The Structure

[Name]
[Email] · [Phone] · [LinkedIn] · [GitHub] · [Personal site if strong]

[Optional: 2-line summary for senior or non-traditional candidates]

EXPERIENCE
  [Company] — [Title]                              [Dates]
  - Bullet
  - Bullet
  - Bullet

EDUCATION
  [School] — [Degree]                              [Year]

TECHNICAL SKILLS
  Languages: ...
  Frameworks: ...
  Infrastructure: ...

That is the structure. Skip "Objective" statements. Skip "Interests" unless directly relevant. Skip the full mailing address — city and country are enough.

The Summary Is Optional

Most junior and mid-level engineers should not have a summary. It takes real estate that is better spent on experience bullets. A hiring manager can infer your positioning from the body of the résumé.

Summaries are worth adding when:

You are a staff or principal engineer with a specific specialty
You are pivoting (backend to ML, IC to management)
You are a non-CS-degree candidate where the story needs a beat of context

Example for a staff engineer: "Staff Engineer with 11 years building distributed data systems at Netflix, Databricks, and Stripe. Specialized in streaming architectures, multi-region consistency, and 10+ engineer tech lead work."

Experience Bullets: The Core of the Résumé

Each bullet must do three things:

Name the project or system (for context)
Describe the technical action (for credibility)
State the outcome (for impact)

Template: [Verb] + [what] + [how/tech] + [outcome with number]

Examples across levels:

L3 / Junior (1-2 years):

Built a batch reconciliation service in Go that compares ledger entries across three payment providers, catching an average of 140 daily mismatches before customer impact
Migrated the notification service from SQS to Kafka, reducing p95 delivery latency from 4.2s to 340ms
Wrote the first integration test suite for the billing service, covering 87% of critical paths and catching two production-level bugs pre-release

L4 / Mid (3-5 years):

Led the rewrite of the session service from monolithic Rails to a Go microservice, handling 40K req/s at p99 80ms; reduced infrastructure costs by $340K/year
Designed and shipped feature flag infrastructure used by 120 engineers across 18 services; enabled 3x increase in deploy frequency
Mentored two junior engineers through their first production launches, both promoted within 18 months

L5 / Senior (5-8 years):

Tech lead for a 6-engineer team rebuilding the search pipeline from Elasticsearch 6 to OpenSearch with vector embeddings; drove the project from design doc through launch over 7 months, improving search NDCG by 18% and reducing cost-per-query by 42%
Owned the design review process for backend engineering (60 engineers), writing the rubric and coaching five other senior engineers to conduct reviews; cut architecture rework post-launch by 60%
Drove the adoption of sqlc across the Go services, replacing hand-written database access with generated code and eliminating an entire class of SQL injection risk

Staff+ (8+ years):

Tech lead for a multi-year migration of the core ledger (processing $14B annually) from Postgres to CockroachDB; set the interface contract, wrote the first three services, and coordinated with four engineering teams plus compliance and SRE
Authored the company-wide RFC process, consolidated 12 competing docs into a single template, and chaired the biweekly design review; cited as the most improved engineering process in the annual survey
Grew the data platform team from 4 to 14 engineers over 2 years as the senior IC and hiring partner; interviewed 80+ candidates and shaped the onboarding curriculum

Notice the trajectory: more scope, more people, more strategic framing, without losing technical specificity.

Technical Skills: The ATS Section

A clean Technical Skills block at the bottom serves two audiences: ATS keyword matching and the human skimmer who wants to check stack fit in five seconds.

Group by category:

Languages: Go, Python, TypeScript, SQL, Bash
Frameworks: React, Next.js, FastAPI, Django, Gin
Data: Postgres, Redis, ClickHouse, Kafka, Snowflake
Infra: AWS (EC2, RDS, Lambda, ECS), Terraform, Kubernetes, Docker, GitHub Actions
Observability: Datadog, Honeycomb, Sentry, OpenTelemetry

A few rules:

List things you can credibly talk about for fifteen minutes in an interview. Do not pad.
Separate "used daily" from "used occasionally" if it matters, typically with a subheading or the order.
Drop Microsoft Office, HTML/CSS (for most backend roles), and dead frameworks (jQuery, AngularJS v1) unless the job explicitly lists them.

Side Projects and Open Source

This section is optional and situational.

Include it when:

You are junior and your work experience is thin
You have a project that went viral or that senior engineers in your field would recognize
You are pivoting into a new tech area and need to show self-directed work

Skip it when:

You are senior and your work bullets already fill the page
Your side projects are tutorial-level (a todo app, a clone of a popular site)
You cannot remember the last commit you made to the project

If you include it, each entry should be one bullet with the link:

Prickly (prickly.dev) — Self-hosted cactus care app written in Rust/Axum + HTMX, 4.2K GitHub stars; wrote a popular post on its state management architecture

Education

Keep it short. For most engineers with 2+ years of experience, education is three lines at most.

BS Computer Science, Stanford University (2019)
MS Machine Learning, CMU (2022) — thesis on retrieval-augmented generation

GPA matters only:

If you graduated in the last 1-2 years
If it is 3.7+ (below that, omit)
For new grads applying to companies where it is a filter (Jane Street, Citadel, some FAANG)

Coursework matters almost never, except for new grads applying to ML, systems, or other specialized roles where coursework is a proxy for skill.

What to Remove

Skip these unless you have a specific reason:

A profile photo (not standard in the US or UK; can trigger bias concerns)
The phrase "References available upon request" (it is assumed)
Generic phrases like "team player," "results-oriented," "passionate about technology"
High school information (for any candidate with a college degree)
Every job you have ever held (stop at the last 10-12 years or the last 4-5 roles)
Certifications that are not relevant (AWS Practitioner is weak for senior engineers; AWS Solutions Architect Professional is stronger)

Common Mistakes

The laundry list of technologies. "Built APIs using Go, Python, Node, Rust, Java, Kotlin, Ruby, and C++." Pick the two or three you actually used meaningfully. The rest looks like padding.

The passive voice. "Was responsible for the migration" is weaker than "Led the migration." Active verbs always.

The scope inflation. "Architected a revolutionary system" when you wrote the CRUD layer of a side project. Senior engineers smell this instantly and the résumé hits the reject pile.

The missing outcomes. "Implemented caching layer." For what? How much faster? How much cost saved? A bullet without a number is half a bullet.

The eight-bullet role. Three to five bullets per role is the sweet spot. Eight bullets at your most recent job suggests you cannot prioritize.

One Last Check

Before you send, do this: read the top third of your résumé out loud. Does it tell a clear story of what you build, at what scale, and with what impact? If not, rewrite the top third. The bottom two-thirds matter less — hiring managers rarely get there unless the top earns their attention.

Tech Resume Guide for Software Engineers