The phrase "applicant tracking system" gets thrown around like a single piece of software, but it isn't. It's a category — Workday, Greenhouse, Lever, iCIMS, Taleo, SuccessFactors, BambooHR, and twenty more — each with its own parser, its own ranking model, and its own quirks. What they share is the shape of the problem they solve for the company: thousands of resumes per posting, one or two recruiters to read them, and a need to triage.

Most blog posts about ATS describe it from the candidate's side: "your resume is being read by a robot." That framing isn't wrong, but it's incomplete. To write a resume that performs well, you have to understand what the system does and what the recruiter does — they're two different audiences sitting at the same screen.

What the parser actually does

When you upload a resume, the ATS runs a parser. The parser converts your file (PDF, DOCX, sometimes plain text) into structured fields the database can search: name, email, phone, work history rows, education rows, skills list. This is the most failure-prone step in the whole pipeline.

What it parses cleanly:

• Single-column layouts with normal section headings (Experience, Education, Skills)
• Standard date formats next to job titles
• Plain-text bullet points
• Embedded text in PDFs (any PDF that lets you copy-paste text)

What breaks the parser, in roughly descending order of severity:

• Tables and multi-column layouts. The parser reads top-to-bottom, left-to-right; a two-column layout often jumbles your sentences into nonsense.
• Headers and footers. Many parsers drop them entirely. If your contact info is in a header, it can vanish.
• Image-only PDFs (scanned resumes, or designs exported from tools like Canva that flatten to image). No text to parse.
• Unusual section names. "Where I've Worked" instead of "Experience" can land your job history in a generic "other" bucket the recruiter never opens.
• Graphical skill bars and rating widgets. The parser sees a logo or an image, not "React 4/5."

You don't need a "minimalist" resume to clear the parser. You need a single column, real text, and conventional section labels. Almost everything else — fonts, colors, even modest formatting — is fine.

What the parser then does with the text

After parsing, the ATS extracts keywords and stores them as metadata against your application record. Some systems run a similarity score against the job description automatically; others wait for the recruiter to apply filters. Either way, the keywords on your resume become the searchable fingerprint of your application.

The keywords that matter are the ones in the job description. Generic skill lists ("Microsoft Office, communication, leadership") barely move the needle because every applicant has them. The keywords that move you up a ranked list are the role-specific ones: tools, frameworks, certifications, methodologies, industry terms. If the posting says "experience with Snowflake," and your resume says "data warehousing on cloud platforms," you've technically described the same thing but the ATS sees no match. Use the term the posting uses, when it's true of you.

This is where most of the tailoring advice comes from, and why it's worth doing. We'll get into the line between "tailoring" and "stuffing" in a separate post — the short version is that adding keywords you've genuinely worked with, in places where they fit, is the entire game.

What recruiters actually see

Here's the part most candidate-facing posts skip: the recruiter doesn't read every resume the ATS ingests. They open a candidate list — usually filtered or sorted — and start scanning.

A typical recruiter dashboard shows, per applicant:

• Name and contact
• Match score (if the ATS computed one)
• Years of experience (parsed from your dates)
• Most recent title
• Education
• A short list of top-matched keywords
• A button to open the full resume

Most resumes are filtered or skimmed before the recruiter ever sees the document itself. If the parser put your years of experience at "1" because it didn't read your earliest job's dates, you're filtered out at "5+ years required." If your most recent title parsed as something generic — "Specialist" instead of "Marketing Specialist" — you may not match the role being filled.

The implication: a clean, parsable resume is not a stylistic preference. It's the difference between being on the recruiter's list at all and being a row of mangled metadata that gets sorted to the bottom.

The ranking score is not the whole story

Some ATS platforms produce a match percentage between a resume and a job description. Others don't. Either way, recruiters do not always sort by score. Many sort by date submitted, or by source (was the candidate referred? did they come through a paid campaign?), or by a custom shortlist they build manually.

Match scores matter most when the volume of applicants is so high that the recruiter never opens applications below a threshold. They matter least for senior roles, niche skills, or referral pipelines, where every application gets a closer look.

What this means for you: getting a high match score helps, but the score isn't the goal. The goal is to be readable, relevant, and parseable enough to land in a list a recruiter will actually open.

Common myths worth retiring

A few claims you'll see everywhere that aren't quite right.

"ATS systems reject resumes." Most don't. They parse, store, and rank. The rejection happens when a recruiter or hiring manager sets a filter, or when an automated screening rule (often customized per posting) excludes records. Saying "the ATS rejected me" usually means "the recruiter's filter excluded my record." Distinct things.

"Use specific fonts to be ATS-friendly." Modern parsers handle any standard font (Arial, Calibri, Helvetica, Garamond, Times). Where fonts can hurt is when they're rendered as images — which only happens if you export weirdly or use a fancy design tool that flattens text. Pick a readable font and move on.

"Hide white-text keywords to game the parser." This was a workable hack in 2012. It is not in 2026. Modern parsers strip text styling and recruiters using preview tools see the hidden text immediately. It's also a fast track to a "this candidate is dishonest" flag, which is worse than not matching.

"PDF gets blocked by ATS." Most major ATS parse PDFs cleanly as long as the text is selectable. Some older systems do prefer DOCX. The best test: open your PDF, try to copy text from it. If you can, the parser usually can too.

What to actually do

If you take three things from how the system works:

The ATS isn't the gatekeeper most posts make it out to be — but it isn't a non-issue, either. It's the layer that decides whether a recruiter ever sees you. Once you understand what it can and can't read, the resume work that matters becomes obvious: write for a person, format for a parser, and use the vocabulary the job actually asks for.