Should I list every programming language I know?

List the languages you would be productive in within a week. Recruiters search by primary stack — listing 12 languages where 8 are surface-level dilutes the signal. Group by depth — "Primary — Python, Go, SQL. Familiar — TypeScript, Rust." This ranks better than a flat list.

How do I show system-design experience on a resume?

With outcomes, not adjectives. "Designed event-driven architecture for payments service handling 12K req/sec at P99 80ms" outranks "experienced in system design." Name the specific systems built and the load they handled.

Should I include GitHub or portfolio links?

Yes for early-career and individual-contributor roles. Most tech recruiters look at GitHub to confirm signal — code quality, recent activity, and project depth. For senior IC and staff+ roles, recruiters skip GitHub and focus on the resume. Either way, a clean, up-to-date GitHub helps.

How do I avoid "junior" framing as a senior engineer?

Lead with scope and impact, not technologies used. "Led 4-person team rewriting payments service, cut error rate from 3% to 0.4%, $1.2M annual revenue impact" reads senior. "Used Python and PostgreSQL to build features" reads junior at any level.

Does open-source contribution matter for ATS?

For some ATS searches, yes — recruiters at companies that hire heavily from open-source communities sometimes filter on specific projects. Listing significant contributions (with project name and link) helps. Drive-by PRs help less than sustained maintainership.

ATS Resume for Software Engineers: Stack Specificity, Scope, and What Tech Recruiters Actually Filter For

Software engineering resumes get filtered by a stack of search criteria that vary dramatically by company segment. Big tech filters for system-design signal and scale. Startups filter for shipping velocity and breadth. Enterprises filter for specific stack alignment. The same engineer can rank #3 at one company and #80 at another based purely on how their resume frames the same work.

This guide walks through how tech recruiters at different segments actually search ATS systems in 2026, the stack specificity and scope signals that move your ranking, and the structural choices that get engineers from junior through staff-and-above into the right pipeline.

How tech recruiters search differently by segment

The same engineer's resume gets read differently by different companies because the filter is different:

Big tech (FAANG-tier and similar) — system-design depth, scale of systems touched, leadership signal at senior+. Less weight on specific framework, more on language fluency and complexity.
Mid-size tech and growth startups — recent stack alignment, shipping velocity, generalist capability, ownership.
Early-stage startups — breadth, end-to-end ownership, willingness to wear multiple hats, scrappiness.
Enterprise IT — specific stack match (Java/Spring, .NET, specific cloud, ERP integrations), domain expertise, certifications.

A "Senior Software Engineer" resume that says "Python, PostgreSQL, AWS" reads very different at each of these. The summary section and the bullets should be tailored to the segment you target.

The stack as searchable keywords

Recruiters search ATS systems by stack. List every language, framework, database, cloud, and tool you have actually shipped code in, but group by depth:

Languages — Python, JavaScript, TypeScript, Java, Kotlin, Go, Rust, C++, C#, Ruby, PHP, Swift, Scala, Elixir
Frontend — React, Vue, Angular, Svelte, Next.js, Remix, Astro, SolidJS
Backend frameworks — Django, Flask, FastAPI, Spring Boot, Express, NestJS, Ruby on Rails, Phoenix, ASP.NET Core
Databases — PostgreSQL, MySQL, MongoDB, Redis, DynamoDB, BigQuery, Snowflake, Cassandra, Elasticsearch
Cloud — AWS (name services — Lambda, ECS, EKS, RDS, SQS, SNS, CloudFront, S3), GCP (Cloud Run, GKE, BigQuery, Pub/Sub), Azure
Infrastructure — Kubernetes, Docker, Terraform, Pulumi, Ansible, Helm
Observability — Datadog, New Relic, Honeycomb, Grafana, Prometheus, Sentry
CI/CD — GitHub Actions, GitLab CI, Jenkins, CircleCI, Buildkite, ArgoCD
Streaming / queues — Kafka, RabbitMQ, Kinesis, NATS
ML / data — PyTorch, TensorFlow, scikit-learn, Pandas, Airflow, dbt, Spark

Format example:

SKILLS
Primary stack — Python, TypeScript, PostgreSQL, AWS (ECS, RDS, Lambda), Terraform
Familiar — Go, Rust, Kafka, Snowflake, dbt

This is parser-friendly AND clear about depth. A flat alphabetical list of 30 technologies signals less than this grouped format.

Scope signal by level

The most important thing senior+ engineering recruiters look for is scope. Every role at senior+ should show:

Technical scope — size of system owned (lines of code, services, queries per second, data volume), criticality (revenue-bearing, customer-facing, internal tooling).
Cross-functional scope — how many people you coordinated with, how many teams, how senior.
Decision scope — what technical decisions you owned versus participated in.
Outcome — business impact, latency improvement, cost reduction, reliability metric.

Bullets that show scope rank higher than bullets that show activity:

✗ "Worked on backend services in Python and Go"
✓ "Owned authentication service (Python, PostgreSQL, Redis) handling 8K req/sec at P99 45ms; cut error rate from 0.8% to 0.05% over Q2"

The numbers are what get the senior engineering recruiter to open the resume.

System design and complexity signals

For senior+ roles, system-design signal is the single highest filter. The resume should have at least one bullet per recent role that demonstrates:

A system you designed (not implemented from someone else's design)
The scale it handles (req/sec, users, data volume, geographic distribution)
A specific architectural choice and the tradeoff it made (consistency vs availability, latency vs cost, sync vs async)

Examples:

"Designed event-driven architecture for order processing using Kafka + DynamoDB Streams; chose eventual consistency over strict ordering to handle 50K orders/sec peak."
"Migrated monolithic Python app to 6-service Go microservices; reduced p99 latency from 2.4s to 380ms, cut compute cost by 38%."
"Led design review for new auth flow supporting SSO across 4 acquired products; resolved trade-off between per-product session lifetime and unified logout."

The structural template for engineer resumes

[Full Name]
[City, State]  ·  [Email]  ·  [Phone]  ·  [LinkedIn]  ·  [GitHub]  ·  [Portfolio]

PROFESSIONAL SUMMARY
Senior software engineer with [N years] building [domain — e.g., distributed
backend systems, ML infrastructure, payments platforms]. Strong on system design,
[language] proficiency, and cross-functional leadership. Most recent — [one
high-signal accomplishment with a number].

EXPERIENCE

Senior Software Engineer  ·  [Company], [City]  ·  Mar 2022 – Present
- Owned authentication service (Python, FastAPI, PostgreSQL) handling 8K req/sec
  at P99 45ms; cut error rate from 0.8% to 0.05% over Q2.
- Led migration to AWS ECS Fargate; reduced infrastructure cost 32% while
  improving deploy frequency from weekly to daily.
- Mentored 3 engineers through senior promotion process.

Software Engineer  ·  [Previous company]  ·  Jun 2019 – Feb 2022
- ...

EDUCATION
B.S. Computer Science  ·  [University]  ·  2019

SKILLS
Primary — Python, TypeScript, Go, PostgreSQL, AWS (ECS, RDS, Lambda), Terraform
Familiar — Rust, Kafka, Snowflake, dbt

Levels and titles to mirror

Tech industry titles loosely map across companies but recruiter searches use specific phrases. Mirror what your target company uses:

Software Engineer (or just "Engineer"), Senior Software Engineer, Staff Software Engineer, Senior Staff, Principal, Distinguished
Senior Member of Technical Staff (MTS) — used at some companies (Salesforce, Snowflake, etc.)
L3-L7 designations (Google, Meta, etc.) — these are internal levels; on a resume use the public-facing title
Engineering Manager, Senior EM, Director of Engineering, VP Engineering — for the management track

The summary line should match the level you target, not your current title. A "Senior Software Engineer" applying for "Staff Software Engineer" roles should phrase the summary as "Senior software engineer ready for staff-level scope" — assuming the experience supports it.

What tech recruiters de-prioritize

Adjective stacks — "passionate," "results-driven," "team player." Skipped.
Coursework lists for senior engineers — relevant for new grads only.
Generic project lists from bootcamps — fine for new grads with no work history; harmful for anyone with shipping experience.
Outdated technology — listing 2010-era tech that you have not touched in five years signals dated skills.

How AI matching helps for tech searches

Tech roles have particularly high title vocabulary variance — and specific stack alignment matters a lot. AI matching reads both the responsibilities and the stack listed in the JD, then surfaces roles where you have substantive overlap rather than just title match. For senior IC searches across companies, an AI matcher saves significant time filtering postings that look adjacent but require different stack depth.

The short version

Tech recruiters search by stack, scale, and scope. Make each visible.
Group skills by depth — primary vs familiar. Flat lists of 30 technologies signal less than tight groupings.
Show scale on every senior+ bullet — req/sec, latency, data volume, team size, business impact.
System-design signal is the single highest filter for senior+ roles. Include at least one design-decision bullet per recent role with the tradeoff named.
Tailor the summary line to the segment — big tech, startup, enterprise. Same content frames differently for each.

For universal ATS principles, see ATS Resume Checker — Why Yours Gets Rejected and How AI Job Matching Works.