ATS and Software Engineering Resumes: What It Actually Does

TL;DR

ATS does not automatically reject resumes. It parses and stores them so recruiters can search later.
Keywords matter because recruiters search the database for them, not because a bot rejects you.
Formatting that breaks parsing (tables, text boxes, headers/footers) makes your resume unsearchable.
Getting keywords in naturally, by describing your actual work, is better than stuffing a skills list.
The goal is a resume that parses cleanly and contains the right terms.

"Optimize your resume for ATS" has become advice so repeated that it's lost most of its meaning.

Most of what candidates do based on ATS advice, including stuffing keyword lists, using white text on white backgrounds, copying job description language verbatim, is either useless or actively counterproductive. The reason is that most candidates (and most of the people giving advice) have a fundamentally wrong mental model of what ATS software does.

Here's the accurate version.

What ATS Actually Does

ATS stands for Applicant Tracking System. It's software that companies use to manage hiring. It does several things:

It stores your application. When you submit a resume through a job board or a company's careers page, the resume goes into a database associated with that job opening and your applicant record.

It parses your resume into structured data. The software reads your resume and tries to extract fields: name, contact info, work history, skills, education, dates. This parsed data is what gets stored and searched.

It lets recruiters search the candidate pool. When a recruiter wants to find candidates for a role, they can search the database by keyword, location, experience level, or other criteria. Candidates whose parsed profiles match show up. Ones whose profiles don't match don't show up.

That's the core of it. ATS is a database and search interface, not a filter that automatically rejects applications before a human sees them.

The Myth of the Auto-Reject

The widespread belief is that ATS rejects resumes that score below some threshold, and no human ever sees them. This picture has some truth in high-volume hiring contexts at very large companies, where some systems do have automated scoring or screening features. But for most mid-size companies and most software engineering roles, that's not what's happening.

What's actually happening is closer to this: your resume gets submitted, it gets parsed into the database, and then it sits there until a recruiter searches for something. If your resume contains the terms they search for, you appear. If it doesn't, you don't.

The result is similar to being "rejected," in that you never get called. But the mechanism is different, and understanding the difference matters for how you fix it.

Automated rejection is a parsing problem. If your resume doesn't parse correctly, the data extracted is garbled or missing, and you won't show up in searches even for things you're qualified for.

The search matching problem is a keyword problem. If a recruiter searches for "TypeScript" and your resume says "JavaScript with type annotations" but never mentions TypeScript, you won't appear even if you know TypeScript well.

These are two separate problems with two separate solutions.

The Parsing Problem

Parsing fails when ATS software can't read your resume structure. This happens because of formatting choices that look fine visually but confuse the software.

Tables. Many candidates use tables to create neat two-column layouts for skills or experience. Tables break parsing reliably. The software often extracts the cell contents in the wrong order or skips them entirely.

Text boxes. Text placed in a Word text box or a PDF text frame is often invisible to parsers. If your contact information is in a text box at the top of the page (a common design choice), the parser may not find your email address or phone number.

Headers and footers. Content in the header or footer sections of a Word document often doesn't get parsed. Don't put your name or contact info in the document header.

Images and graphics. Charts, icons, progress bars for skill ratings, profile photos. None of this is readable by a text parser. A skills section that shows "Python: ████████░░" instead of "Python" is a parser's nightmare.

Non-standard fonts and special characters. Unusual Unicode characters, decorative bullets, or non-standard fonts can cause parsing errors that garble surrounding text.

Two-column layouts. Not always a problem, but some parsers read a two-column resume left-to-right across the full page width, which means they mix content from your left column with content from your right column. The extracted text becomes nonsensical.

The solution to parsing problems is straightforward: use a simple, single-column layout. Use real text, not images. Use standard bullet characters. Put your contact info in the body of the document, not in a header.

A resume that looks slightly less designed but parses cleanly is worth more than a beautifully designed resume that the system can't read.

The Keyword Problem

Once your resume is parsing correctly, the question becomes: will it show up when a recruiter searches for the right terms?

Recruiters search by technologies, by job titles, by skills, and sometimes by companies or schools. They're looking for overlap between what the job requires and what's in the candidate pool.

The most important keyword work for a software engineer is in the technical stack: the languages, frameworks, databases, tools, and platforms you have real experience with.

The mistake candidates make here goes in two directions.

The first direction is leaving things out. If you know React but only mention it in a single project bullet point as "a JavaScript framework," and never use the word "React" explicitly, a search for React candidates may not surface you. Call things by their names.

The second direction is listing things you barely know. Padding a skills section with every technology you've ever heard of is a bad strategy. If you list Kubernetes as a skill and a technical interviewer asks you about Kubernetes, you're in trouble. Only list things you can actually talk about in an interview.

How to Get Keywords In Naturally

The right approach is not to write your resume and then go back to stuff keywords into it. The right approach is to write your experience and projects with technical accuracy, which means the keywords end up there because they're part of an honest description.

Compare these two approaches:

Keyword-stuffed skills dump: "React, JavaScript, TypeScript, HTML, CSS, Node.js, Express, MongoDB, PostgreSQL, Redux, REST APIs, GraphQL, AWS, Docker, Kubernetes, CI/CD, Git..."

Natural integration in bullets: "Built the front-end onboarding flow in React and TypeScript, connecting to a Node.js/Express API backed by PostgreSQL" and "Containerized the application with Docker and set up a GitHub Actions deployment pipeline."

Both approaches get keywords into the resume. The second approach also tells you what the person actually did with those technologies. A recruiter searching for "TypeScript" finds you in both cases. But the second version is also useful to a hiring manager who reads your resume, which matters just as much.

The skills section is still worth including. It functions as a quick reference for the recruiter scan and as a parsing-friendly place to name technologies you haven't had room to mention in bullets. But it shouldn't be doing all the keyword work. Your bullets and your project descriptions should already contain your most important technical terms.

Tailoring to Specific Job Descriptions

The most targeted version of keyword optimization is looking at a specific job description and checking whether your resume contains the terms they mention.

If a job description says "experience with containerization and orchestration" and your resume never mentions Docker or Kubernetes (even though you've used them), that's a gap to close. You're not inventing experience. You're making sure the experience you have is visible.

The easiest way to do this is to read the job description, pull out the five or six technologies and skills they mention most prominently, and scan your resume for each one. If something is missing but you have the experience, add it.

Writing strong bullet points is the right way to integrate most of these terms. A bullet that says "Optimized PostgreSQL queries to reduce API response times" contains the keyword "PostgreSQL" and also shows what you did with it.

What Doesn't Help (and What People Think Helps)

A few popular ATS tactics that range from useless to counterproductive:

White text keywords. Adding keywords in white text (invisible to humans but visible to parsers) used to be mentioned in resume advice. Modern ATS software detects this and it can get your application flagged. Don't do it.

Copying the job description verbatim. Pasting large blocks of text from a job posting into your resume looks strange to any human reader and doesn't help with keyword matching in a meaningful way beyond just using the right terms naturally.

Generic "ATS-friendly templates." There's nothing magical about templates marketed as ATS-friendly. What matters is that your document uses clean formatting. A simple Word document or Google Doc export to PDF with single-column layout and real text is fine.

Obsessing over keyword density. ATS search is mostly about presence, not frequency. Mentioning "React" once in a relevant context is sufficient. Mentioning it seven times in a single-page resume looks strange.

The Right Mental Model

Think of ATS as a filing and retrieval system, not a gatekeeper. Your job is to make sure your resume gets filed correctly (parsing) and that it gets retrieved when the right searches happen (keywords).

A clean, honest, well-written resume that uses technical terms accurately will do both of those things without special optimization tricks. The energy you'd spend gaming the system is better spent on the content.

After you've handled parsing and keywords, the recruiter still has to read your resume and decide in 10 seconds whether to move forward. ATS optimization gets you into the pool. The quality of your writing and the strength of your experience get you out of it.

The software engineering resume guide covers how to structure every section so the resume both parses well and reads well. And if you're wondering whether your current resume has red flags beyond the ATS question, common resume mistakes engineers don't realize they're making covers the specific problems that cause otherwise-qualified candidates to get skipped.

If you want a structured review of your resume with specific feedback on both ATS readiness and content quality, here's how the Globally Scoped program works.