The Software Engineer's ATS Keyword Guide (Junior to Staff)

Only 25% of resumes submitted to major companies make it past ATS to a human reader. For software engineering roles, that number might actually be worse: job descriptions are packed with specific tool names, version-specific frameworks, and cloud acronyms that have to match exactly.

"JavaScript" and "JS" are not the same string to most parsers. Neither are "Amazon Web Services" and "AWS."

This isn't a quirk. It's the core mechanic you're up against.

ATS Is a Search Engine, Not an AI

Before we get to the keyword lists, it's worth understanding what's actually happening. If you haven't read how ATS actually works, the short version is this: ATS doesn't assess your skills. It extracts text, parses it into fields, and checks whether your resume contains the terms the recruiter configured. It's closer to a SQL query than a judgment call.

A few things follow from this:

Acronyms are not interchangeable. According to uppl.ai, writing "Amazon Web Services (AWS)" in your skills section covers both forms. Writing just "AWS" only covers one. Same goes for "JavaScript (JS)" or "Kubernetes (K8s)". Use the full term, optionally followed by the abbreviation in parentheses.

Layout kills parsing silently. Toptal's resume guide notes that tables, multi-column layouts, text boxes, and contact info buried in Word headers/footers all break parsers. Your five years of distributed systems experience might simply not register. Use a single-column layout with standard section headings: Work Experience, Skills, Education. That's it. If you want to know whether columns specifically are the enemy, yes, they are.

File format matters for portals. When submitting through a careers portal, DOCX is generally safer. When emailing a person directly, PDF is fine. There's a longer breakdown at DOCX vs PDF for ATS.

Now, the keywords.

The Three-Tier Model

Not all keywords carry equal weight. A useful way to think about them, borrowed from Jobscan's keyword research:

Tier 1 (knockout criteria): These are the terms recruiters filter on first. If they're missing, you're invisible before anyone reads a word. For software engineering roles, Tier 1 means your job title match and your core stack.

Tier 2 (differentiators): Present in 40-70% of job descriptions for your target roles. These separate shortlisted candidates from each other.

Tier 3 (emerging/niche): Appear in fewer postings but signal depth and relevance for specific teams. Use them when they're genuinely in your background.

Keyword Tiers by Seniority

Junior / Entry-Level

Tier 1 knockout terms: "junior software engineer", "software developer", your primary language (Python, JavaScript, TypeScript, Java), at least one framework (React, Node.js, Django, Spring Boot).

Tier 2 differentiators: Git, GitHub, "unit testing", "REST API integration", "code review participation". For the projects section, name the specific tech used, not just "web app". Say "React + Node.js + PostgreSQL" rather than "full-stack project".

Tier 3 bonuses: TypeScript, Next.js, Docker, AWS Lambda, Tailwind CSS. These appear in junior postings with increasing frequency. If you've touched any of them in a project, they belong in your skills section.

Action verb note: Formation.dev's resume guide points out that hiring managers distinguish between "built", "implemented", "debugged" (junior signals) and "designed", "architected", "led" (senior signals). Use the right tier. "Built a REST API" is accurate and appropriate for a junior. Claiming "architected" for a tutorial project is a red flag.

GitHub: For entry-level roles, Flatiron School's data shows GitHub is your primary portfolio surface. Put it in your header alongside your email: github.com/username. Include it in your contact section and link specific projects from your Projects section. Make sure the repos you link have real READMEs. ResumeWorded notes that an empty or messy profile can hurt more than help. If your GitHub isn't polished, either clean it up first or leave out the link.

Mid-Level (3-6 years)

Tier 1: "software engineer" (without "junior") matching the exact title in the posting. If the JD says "Software Engineer II", mirror that. If it says "Software Engineer, Backend", use that in your summary.

Tier 2: "production systems", "on-call", "incident resolution", "SLA/SLO", "CI/CD", "cross-functional collaboration", "code reviews", "mentored junior engineers".

The ownership verbs matter here: "owned", "led", "designed", "delivered end-to-end". Jobscan shows these terms appear far more often in shortlisted mid-level resumes. If you've been on-call, say so. If you've resolved production incidents, say so with numbers: "reduced mean time to resolution by 40%."

Tier 3: "performance optimization", "observability", "A/B testing", "scalability", "feature flags". Use these when they're in the JD and genuinely in your background.

GitHub: Still worth including, especially if you have open-source contributions or side projects that show initiative. Link specific repos inline where relevant: under a project bullet or in your experience for a meaningful side project you ran in parallel.

Senior / Staff+

Tier 1: "senior software engineer", "staff software engineer", "technical lead", matching the seniority in the posting. This is a knockout: if the JD says senior and your resume says nothing, filters catch it.

Tier 2: "system design", "architecture decisions", "distributed systems", "high-throughput", "technical leadership", "defined standards", "drove adoption", "reduced technical debt", "roadmap influence".

Tier 3: "hired and mentored engineers", "improved reliability", "principal engineer", "engineering manager" (if relevant), "platform engineering", "internal tooling".

Quantification is non-negotiable at this level. Formation.dev specifically calls out that hiring managers look for complexity, scale, and ownership evidence. That means: "reduced p95 latency from 800ms to 120ms", "cut infrastructure costs by 35%", "system serves 50M monthly active users". Scale and outcome, not just responsibility. There's a full framework for writing these in the quantify achievements guide.

Stack-Specific Clusters

Don't just list languages. Group them so the parser and the human both see a coherent stack.

Backend: Node.js / Express / NestJS, Java (Spring Boot), Python (Django, Flask, FastAPI), Go. Databases: PostgreSQL, MySQL, MongoDB, Redis, DynamoDB. Messaging: Kafka, RabbitMQ. APIs: REST, GraphQL, gRPC. Cloud: AWS / Azure / GCP. Infrastructure: Docker, Kubernetes, Terraform, CI/CD.

Frontend: JavaScript, TypeScript, HTML, CSS, responsive design, accessibility (WCAG). Frameworks: React, Next.js, Vue.js, Angular, Svelte. Tooling: Webpack, Vite, ESLint, Storybook. Concepts: SSR, SSG, PWA, Web Vitals, component architecture, state management.

Full-stack: Combine both clusters and add: "end-to-end feature development", "API design and integration", "database schema design", "deployment pipelines".

The skills section ordering guide covers how to sequence these so the most role-relevant skills surface first.

How Many Keywords Is Enough

There's no magic number, but there is a floor. Our analysis of keyword density found that resumes hitting fewer than 50-60% of a job description's key terms rarely pass competitive filters. The practical target: cover every Tier 1 term from the JD, most of the Tier 2 terms you can legitimately claim, and selectively include Tier 3 where relevant.

The mirror test: read the job description, highlight the 8-10 most repeated or emphasized terms. Check whether each one appears in your resume verbatim. If you have the experience but used different vocabulary, rephrase. "Managed deployments" becomes "CI/CD pipeline management" if that's what the JD says. You're not inventing skills. You're using the employer's dictionary.

The Scaling Problem

One tailored resume is 15-20 minutes of work. Three keywords swapped, a summary rewritten, skills reordered to match the JD. That's fine for five applications a week.

At 20-30 applications per week, the math breaks. Most engineers don't do it. They submit the same resume everywhere and get a 2-3% response rate, which, for what it's worth, is the normal baseline.

If you're applying at volume, BulkResumes generates individually tailored versions from your base resume for each job description, using the vocabulary of that specific posting. The keyword matching logic is built in.

The Short Version

• ATS is a keyword search engine. Mirror exact terms from the JD.
• "AWS" and "Amazon Web Services" are not the same string to most parsers. Write both.
• Tier 1 (job title + core stack) is a knockout: missing it means invisible.
• Seniority verbs matter: "built" for junior, "architected" for senior. Be accurate.
• GitHub belongs in your header for junior roles; link specific repos for senior ones.
• Clean single-column layout, standard headings, DOCX for portals.
• At volume, keyword-tailoring every application manually is the bottleneck.