How ATS Software Actually Parses and Rejects Your Resume

Kien Phan — Wed, 03 Jun 2026 09:07:35 +0000

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." 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. As someone who spent time building an ATS checker, I've seen the output from enough parsed resumes to know exactly where things go wrong.

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 converts your document — PDF, DOCX, or otherwise — 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 running OCR on a handwritten letter, then having a script guess where each paragraph begins and ends. More chaos in the original means worse output.

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

This is the 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 keyword matching. 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. The resulting score determines where you appear in the recruiter's queue.

A few things worth knowing about how this actually works:

Exact phrasing often beats semantic equivalence. "Stakeholder management" and "managing stakeholders" may be treated as different tokens in older systems. Mirror the job description's exact phrasing wherever it accurately describes your experience.

Keyword placement affects score weight in some systems. Terms in your summary or early in experience bullets tend to carry more weight than identical terms buried at the bottom.

Newer platforms with NLP check context, not just presence. "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 posting. A 60% match against a niche role with 40 applicants might get you through. The same score against a viral posting with 800 applicants 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. After extraction, the data in the ATS is garbled, incomplete, or misattributed. You never find out.

Tables and Multi-Column Layouts

This is the most widespread failure. When a parser hits a table, it reads across rows instead of down columns. Two parallel columns get merged into incoherent strings.

A two-column resume with job history on the left and skills on the right extracts as alternating fragments of both. Your job title, company, location, and dates can collapse onto one line, and bullets stop being associated with the right role — so "5 years of engineering experience" may fail to map to any recognized work history record.

Headers and Footers

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

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

Text Boxes and Sidebars

Content in 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 slick, it may be completely missing from the parsed output.

Images and Icons

Inline icons — a phone icon next to your number, a LinkedIn logo next to your URL — are invisible to text parsers. If your name or any section header is rendered as an image (common in design-heavy templates), the parser won't find it. Submitting a scanned resume as a JPEG produces the same problem at scale: the entire document is one large image with no extractable text.

Non-Standard Section Headings

ATS systems are trained to recognize section boundaries. They know "Work Experience," "Professional Experience," "Employment History." They are less reliable with creative alternatives. Headings like "Where I've Made an Impact," "My Story So Far," or "Toolkit" may fail to map to a recognized field — and content beneath them may be skipped or misattributed.

Date Format Inconsistency

Parsers need to extract date ranges to calculate years of experience. "Jan 2019 – Mar 2022" is fine. Problems arise with unusual formats, ambiguous year-only ranges, or dates embedded in sentences. If a parser can't extract your employment dates reliably, it may assign zero years of experience to a role — which collapses your seniority score against requirements.

The Plain-Text Test

The simplest way to catch parse failures before you submit: select all text in your resume and paste it into a plain text editor. Look at the output.

Contact details missing? They were in a header. Columns jumbled? You have a table or multi-column layout. Sections out of order? Non-linear structure. Whatever looks broken in plain text is exactly what the ATS will see.

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

What This Means for Your Format

Given how parsers work, the formatting rules stop being arbitrary:

Single column. Always. The visual appeal of a two-column template is not worth the parsing risk.
No tables. Use bullet points and line breaks instead.
No text boxes. If your template uses them, find 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.

A clean single-column resume with good typography and strong content looks more professional than most over-designed templates — and it parses cleanly.

One Thing Worth Doing Before Every Application

After fixing your formatting, the remaining variable is keyword alignment with each specific job description. No single resume scores well against every posting. The discipline is tailoring: checking which terms appear in the job description and making sure they appear in your resume where accurate.

I built CVPosh's free ATS checker to automate exactly this — upload your resume, paste the job description, and get your match score plus which specific terms are present or missing. It takes about 90 seconds and removes the guesswork.

The Bigger Picture

ATS systems aren't trying to screen out qualified candidates. They're trying to help recruiters manage volume. "Beating" the system misframes the goal.

The real goal is making sure your resume converts to accurate, complete data. If the parser reads your work history, skills, and dates correctly, the system can evaluate you fairly. The formatting rules above aren't tricks — they're the conditions under which automated parsing works correctly.

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

DEV Community: Kien Phan