How ATS Software Actually Parses and Rejects Your Resume

You applied. You heard nothing. You assumed you weren't qualified.

You might have been perfectly qualified — and a parser threw your resume in the bin before any human laid eyes on it.

Most ATS advice stays on the surface: "use keywords," "avoid tables." That's useful, but it skips the more interesting question: why do these things matter? What is actually happening inside the system when it reads your resume?

This is that explanation.

What an ATS Parser Actually Does

When you upload a resume to an applicant tracking system, the first thing that happens is not a keyword search. It's a text extraction step. The system attempts to convert your document — whether PDF, DOCX, or something else — into a flat, unformatted string of text. Then it tries to segment that string into structured fields: name, contact info, job titles, companies, dates, education, skills.

Think of it like trying to read a handwritten letter by first photocopying it, then running optical character recognition on it, then having a junior analyst guess where each paragraph begins and ends. The more chaos in the original, the worse the output.

The structured data it extracts gets stored in a database. When a recruiter searches for "5 years Python" or "product manager fintech," they're querying that database — not your beautiful original document. Your formatting no longer exists at this point. Only the extracted fields do.

This is the core thing most candidates don't internalize: your resume is converted to data before it is ever evaluated. If the conversion is wrong, the evaluation is wrong.

How Keyword Matching and Scoring Work

Once parsed, most ATS platforms score your resume against the job description using some form of keyword matching. The specifics vary by platform — Workday, Greenhouse, Lever, iCIMS, and Taleo all have different scoring logic — but the general mechanics are similar.

The system identifies required and preferred keywords in the job description, then checks your parsed resume for those terms. It looks for exact matches and sometimes close variants. The resulting score is typically a percentage or a ranked number that determines where you appear in the recruiter's queue.

A few things about how this scoring works in practice:

Exact phrasing often beats semantic equivalence. If the job description says "stakeholder management" and your resume says "managing stakeholders," some systems will count that as a miss. Older systems in particular treat these as different tokens. The safest approach is to use the job description's exact phrasing wherever it accurately describes your experience.

Keyword placement affects score weight in some systems. Terms that appear in your summary section or early in your experience bullets tend to carry more weight than identical terms buried at the bottom. Lead with the language that matches the role.

Both the presence and context of keywords matter on newer platforms. Modern ATS tools with NLP capabilities don't just count occurrences — they check whether the keyword appears in a plausible context. "Managed a Python codebase" scores better than "familiar with Python" for a senior engineering role.

Your score is relative, not absolute. You're ranked against other applicants for that specific posting. A 60% match against a niche role with few applicants might get you through. The same score against a popular role with 800 applications might put you on page 12.

What "Parse Failure" Looks Like — And Why It Happens

Parse failures are the silent killers. Your resume looks correct to you. It looks correct when you open it. But after extraction, the data in the ATS is garbled, incomplete, or misattributed.

Here are the most common causes and what happens in each case:

Tables and Multi-Column Layouts

This is the most widespread formatting failure. When a parser encounters a table, it typically reads across the row rather than down each column. The result: the content of two parallel columns gets merged into incoherent strings.

What you designed:

Software Engineer        2019–2022
Acme Corp, London

What the parser may extract:

Software Engineer 2019–2022 Acme Corp, London

That's actually a relatively good outcome. A worse outcome is:

Software Engineer        Acme Corp, London        2019–2022 Led a team...

Now your job title, company, location, and dates are all on one line, followed by a bullet that the parser can't associate with the right job. Your "5 years of engineering experience" may now fail to map to any recognized work history record.

Multi-column layouts have the same problem. The parser does not know your resume has two columns. It sees a stream of characters and tries to read them left to right, top to bottom. A two-column resume with your job history on the left and your skills on the right may extract as alternating fragments of both.

Headers and Footers

Contact information in the document header is a classic mistake. Many ATS platforms extract the document body only, skipping the header and footer entirely. Your name and email may not exist in the system at all. The recruiter who wants to call you back literally cannot find your contact details.

Place your name, email, phone number, and LinkedIn URL in the body of the document, at the top, as plain text.

Text Boxes and Sidebars

Content inside a text box is often ignored entirely, or extracted out of order. If your skills section or summary is in a sidebar text box because your template looks sleek, it may be missing from the parsed output altogether.

Images and Icons

Inline icons — a small phone icon next to your number, a LinkedIn logo next to your URL — are invisible to text parsers. More problematically, if your name or any section header is rendered as an image (common in some design-heavy templates), the parser will not find it.

Scanning your resume as a PDF from a photo or printed copy produces the same issue at scale: the entire document is one large image with no extractable text. This is especially common when candidates photograph their resume and submit it as a JPEG or a non-text PDF.

Non-Standard Section Headings

ATS systems are trained on large corpora of resumes to recognize section boundaries. They know "Work Experience," "Professional Experience," "Employment History." They are less reliable with creative alternatives.

Section headings like "Where I've Made an Impact," "My Story So Far," or "Toolkit" may fail to map to a recognized field. The content beneath them may be parsed but not attributed to the correct section — or skipped.

Date Format Inconsistency

Parsers need to extract date ranges to calculate years of experience. Formats like "Jan 2019 – Mar 2022" or "01/2019 to 03/2022" are generally fine. Problems arise with unusual formats, ambiguous years-only ranges, or dates embedded in sentences rather than standing as structured fields.

If a parser can't reliably extract your employment dates, it may assign zero years of experience to a role — which collapses your seniority score.

The Plain-Text Test

The simplest way to spot parse failures before you submit is the plain-text test. Select all the text in your resume document and paste it into a plain text editor (Notepad on Windows, TextEdit in plain text mode on Mac). Look at the output.

If your contact details are missing, they were in a header. If columns are jumbled, you have a table or multi-column layout. If sections are out of order, your structure is non-linear. Whatever looks broken in plain text is exactly what an ATS parser will see.

A well-formatted resume should paste as clean, readable, top-to-bottom text with clear section breaks and correctly ordered content.

What This Means for Your Resume Format

Given how parsers work, the formatting rules become obvious rather than arbitrary:

• Single column. Always. The visual appeal of a two-column template is not worth the parsing risk.
• No tables. Use plain bullet points and line breaks instead.
• No text boxes. If your template uses them, use a different template.
• No images. Not icons, not photos, not decorative elements.
• Contact info in the body. First thing in the document, plain text.
• Standard section headings. Work Experience, Education, Skills, Certifications. Boring is correct.
• Consistent date formatting. Pick one format and use it everywhere.

None of this means your resume has to look ugly. A clean single-column resume with good typography, appropriate whitespace, and strong content looks more professional than most over-designed templates — and it parses cleanly.

One Thing Worth Doing Before Every Application

After you've fixed your formatting, the remaining variable is keyword alignment with each specific job description. No single resume will score well against every posting. The discipline is tailoring: checking which key skills and terms appear in the job description and making sure they appear in your resume where accurate.

The manual version of this is reading the job description, highlighting terms, and cross-checking your resume. I built CVPosh's free ATS checker to automate exactly this — upload your resume, paste the job description, and it shows you your match score and which specific terms are present or missing. It takes about 90 seconds and removes the guesswork.

The Bigger Picture

ATS systems are not trying to screen out qualified candidates. They're trying to help recruiters manage volume. The problem is that most resume advice focuses on "beating" the system, which misframes the issue.

The real goal is making sure your resume converts to accurate, complete data. If the parser reads your work history correctly, your skills correctly, and your dates correctly, then the system can evaluate you fairly against the role. The formatting rules above are not tricks — they're the conditions under which an automated system can do its job.

Get the conversion right. Then make sure the content is strong. That combination — clean parse, relevant content — is what actually moves your resume to the top of the queue.