We'd like to use Microsoft Clarity to see how visitors use this site. It records clicks, scrolling and page views. It runs only if you allow it. See our Privacy Policy.

Skip to content
Country:Global
Login

What an ATS actually rejects (and what it does not)

An ATS rejects form answers, not fonts. The real damage is empty fields: what parsing breaks, a worked example and how to check yours.

The ApplyHustle teamEditorialUpdated 9 min read
A thick stack of paper with its top sheets fanned open.

An applicant tracking system does not read your resume and form a view of it. Before anything else happens, a parser converts the document into a database record: name, contact details, employers, job titles, date ranges, qualifications, skills. Everything that follows, every search a recruiter runs and every filter they apply, operates on that record rather than on your file. Whether the software then rejects anyone by itself is a separate question, taken apart in no robot rejected your resume.

This post is about the conversion itself, because that is where most applications get hurt. The failure mode is not a verdict but an empty field. A recruiter filtering on three or more years of Python never sees a rejection for you; they see nothing at all, because the field that should carry your nine years of Python carries nothing. Nobody decided to exclude you. The record never qualified for the query.

The short answer: what gets rejected automatically

Software rejects an application by itself in one common case: an answer on the application form that the employer marked as disqualifying. Greenhouse calls these application rules, Oracle Taleo calls them disqualification questions, and SmartRecruiters lets a yes or no or dropdown screening question act as a knockout. Those rules read your form answers. They do not read your resume's fonts, layout or design.

  • Rejected automatically: a form answer outside what the employer configured, such as work authorisation, a required licence or willingness to relocate.
  • Not rejected, but harmed: a resume whose parsed record has empty or misfiled fields, which then fails searches, filters and AI ranking.
  • Not judged at all: fonts, colour, bold, and the choice between a PDF with a real text layer and a .docx.

What a parser actually does with your file

Parsing runs in two steps, and knowing them explains almost every failure. First, extraction: the software pulls the raw text out of the document, in reading order, as one continuous stream. Second, segmentation: it cuts that stream into fields, deciding that this line is a job title, this pair of tokens is a date range, and this block belongs under Education.

The two steps fail differently. Extraction failures lose text outright, so a section that lived inside a graphic simply vanishes from the record. Segmentation failures keep every word but file it wrongly, so a job title lands in the skills field or a role reads as lasting zero months. The second kind is the nastier one, because the text all survived and the record is still wrong, which no amount of proofreading the original document would ever reveal.

A worked example: the PDF and the record

Take a two-column resume with the email address in the page header, a skills sidebar on the left, and a current role written as Data Analyst, Brightwell Foods, Mar 2021 to Present. Here is the kind of record a parser that reads straight across the page can produce from it. The candidate and employer are invented; the failure pattern is not.

  • Name: Priya Sharma. Parsed correctly, because it sat in the body of the page.
  • Email: empty. The address lived in the document header, which this parser skipped.
  • Job title: Data Analyst Python SQL. The sidebar line was spliced into the title.
  • Employer: Brightwell Foods Tableau. The next sidebar line landed here.
  • Dates: Mar 2021 to an unread end date, so tenure computes as zero months.
  • Skills: empty. Every skill was filed somewhere else.

Every word of the original survived, and the record is still useless. A search for Python misses it because Python is filed as part of a job title, a filter on three years of experience drops it because tenure reads as zero, and nobody can email the candidate. Proofreading the PDF would never have shown any of it.

What modern parsers handle well

The current generation is considerably better than the folklore assumes. A PDF with a real text layer usually parses cleanly, and so does a plain .docx. Colour is fine, bold and italics are fine, ordinary bulleted lists are fine, and a sensible choice of font makes no difference at all. The commonly repeated advice to strip a resume back to a bare page of Times New Roman is a decade out of date.

Segmentation has improved too. Most mainstream systems now use trained statistical models rather than brittle keyword rules, which means they tolerate reasonable variation. A heading that says Work Experience rather than Experience is recognised without complaint, and dates in most common formats are read correctly. The improvement is real, but it has narrowed the failure surface rather than removed it, and what remains breaks in specific, predictable ways.

The constructions that still break

Five constructions still break current parsers often enough to avoid, and each fails for a mechanical reason rather than an aesthetic one. The design side of this, columns, skill bars and icons, is covered in your resume is beautiful, the parser sees a blank page; the list below is about the data.

  • Multi-column layouts, because many extractors still read straight across the page, splicing a line of your skills sidebar into the middle of a job description and handing the segmenter a sentence that exists nowhere on your actual resume.
  • Contact details placed in the document header or footer, which some parsers skip entirely, producing a record that parses perfectly and cannot be replied to.
  • Text boxes and floating objects that hold real content, because a parser follows the main document flow and may never look inside anything floating beside it.
  • Inconsistent date formats, where one role says 2021 to 2023 and the next says 03/2023 onwards, so the software misreads one of them and a tenure computes as zero months.
  • Invented section headings, because segmentation maps headings to known fields, and a heading like Where I Have Worked maps to nothing, leaving everything beneath it unfiled.
A diagram showing a resume whose skills are trapped in an image, producing a parsed record with an empty skills field, so a recruiter search for three plus years of Python curves straight past the record to other candidates, never retrieving it.
The failure mode is parsing rather than judgement: the empty field never matches the filter, so the recruiter searching for the skill simply never sees you.

Notice what is not on the list. A simple table of plain text usually survives a modern parser, though the extraction order of its cells depends on the tool that built it, so a table is a risk you take rather than a guaranteed loss. Colour, bold, a readable font and a PDF with a text layer are not on it either.

Why an empty field costs more in 2026

Search used to be the only thing that read the record. Now the ranking features built into the larger systems read it too. In a release that reached production on 7 August 2026, Workday's HiredScore began checking each screenable qualification on a requisition against the candidate's parsed resume, with the basic qualifications deciding whether a candidate lands in its A and B or its C and D grades; employers opt in. Greenhouse's Talent Matching sorts applicants into Strong, Good, Partial and Limited matches, and routes a resume it cannot analyse to Needs manual review.

The vendors say neither feature rejects anyone by itself. But the grader can only find a qualification the parser kept, so a misfiled record now drops down the ranked list as well as missing the search.

A parser never tells you it failed. It files an incomplete record and lets the silence do the explaining.

The copy-paste test

You can see the extraction half of this yourself in under a minute. Open your resume, select all, copy, and paste into a plain text editor. What appears is close to what the extraction step produces, and each symptom points at a cause. Scrambled order means your columns are interleaving. Missing chunks lived in images or text boxes. A name that pastes as boxes and question marks is a font that did not embed as text, and an empty paste is an empty application.

The test has one blind spot: it shows extraction, not segmentation. Text can paste in perfect order and still be filed into the wrong fields, with dates unread and titles attached to the wrong employer. When an application form offers to fill itself in from your resume, read every field it fills before you submit, because that form is the parsed record. ApplyHustle's free ATS check covers the rest: it names a file it cannot read instead of scoring it, scores formatting and readability, and, given a job description, lists which of its keywords and requirements your resume shows and where.

What to change today

Every fix here is formatting work, not a rewrite, and one sitting covers the lot. Move to a single column. Put your name, email and phone number in the body of the first page rather than the header. Use the section headings a parser expects: Experience, Education, Skills. Take any fact that matters, a title, a qualification, a tool, out of graphics and into plain text.

  • Name, email, phone and city in the body of page one, never in the header or footer.
  • One column for everything a parser has to read.
  • Headings named Experience, Education and Skills, plus Certifications if you hold any.
  • Every date as month and year, written the same way on every line, with Present for a current role.
  • Job title and employer in the same order for every role, on one line or two adjacent lines.
  • No fact that exists only inside an image, chart, icon or text box.
  • A PDF exported from a word processor, or a .docx, unless the posting asks for a specific format.

Then standardise your dates, because they feed the filters recruiters run. Pick one format, month and year, and apply it to every role without exception. Tenure and total experience are computed from those pairs, and a misread date does not produce an error message; it produces a candidate with three years of experience where there should be seven, quietly failing every filter set above the misread number.

None of this caps how good the document can look. Typography carries hierarchy through a parser untouched, and layout tricks do not, which settles the trade. Once the record parses cleanly, both of your readers, the machine that retrieves and the person who decides, are finally judging the same thing: the words.

Questions about what an ATS rejects

Does an ATS reject PDFs? No. A PDF with a real text layer parses as well as a .docx in current systems. A PDF that is a scan, or a design export where the text became images or outlines, parses as empty, and that is a file problem rather than a format problem.

Will a table get my resume rejected? Not rejected, but possibly misfiled. A table of plain text often survives; a table used to fake two columns is read row by row and can splice unrelated cells together.

How do I know whether my resume parsed correctly? Run the copy-paste test for extraction, then read the fields an application form fills in from your file. A wrong title, a missing date or an empty email field there is the same record a recruiter will search.

Share this article

Keep reading