Resume Parser Errors: Why Your Application Looks Broken in the ATS

You upload your resume, click "Autofill from resume," and the application form fills in your job title as your employer, leaves your phone number blank, and lists your 2019 internship as your current role. That's not a glitch on one site. It's a resume parser misreading your file, and the same misreading may be what a recruiter sees in your candidate profile.

Parsing errors are frustrating because they're invisible from your side. Your PDF looks perfect. The problem lives in how software extracts and labels the text underneath the design.

This guide explains what a resume parser does, the most common parsing errors and their causes, how to test your file in about ten minutes, and the specific fixes that make every field read cleanly. You'll also get a decision table for two-column layouts and a before-and-after view of a broken parse.

What a resume parser does and why errors matter#

A resume parser converts a document into structured data. Instead of one block of text, the applicant tracking system gets labeled fields it can store, search, display, and compare.

Most parsers work through the same stages:

1. Extract the text from the file, in the order the software thinks it should be read.
2. Split the text into sections, usually by recognizing headings like "Experience" and "Education."
3. Identify entities inside each section: names, employers, job titles, dates, degrees, skills.
4. Normalize what it found, such as turning "Jan 2023 – Present" into a start date and a current-role flag.
5. Store the fields in your candidate profile and, often, prefill the application form.

Which fields matter most#

Not all fields carry equal weight. Greenhouse, for example, says its Talent Matching feature uses parsed skills, job titles, years of experience, employment start and end dates, and company names, while names and contact details aren't used for matching, according to its data processing FAQ.

Parsing and matching are separate steps#

It helps to keep two jobs apart. Parsing turns your file into fields. Matching compares those fields with a job's requirements. A strong match is impossible if the parse is broken, because the matching step only sees what the parser extracted.

Parsers have become more sophisticated. Greenhouse, for instance, says it uses fine-tuned language models, each trained for a specific extraction task, to turn resumes into structured data. Better parsers recover from more layout quirks, but they can't recover text that isn't in the file, and they can still mislabel a field when your structure is inconsistent. A clean parse is the foundation; everything else, including your ATS score and keyword match, is built on top of it.

Why parsing errors cost interviews#

Parsed data feeds the tools recruiters use. Harvard Business School research found that more than 90% of employers using a recruiting management system relied on it to make a first cut or rank applicants, as summarized by HBS Working Knowledge. Those cuts and rankings run on fields, not on your design.

If your title lands in the wrong field, a recruiter's title search may skip you. If your dates break, a "5+ years" filter may undercount you. And if the parsed profile looks scrambled, the recruiter's first impression is a mess, even when your actual file is polished. For the basics of how these systems work end to end, see what an applicant tracking system is.

How a resume parser reads your file#

Understanding the mechanics makes the fixes obvious. Three things decide whether a parse succeeds: whether there's text to extract, what order it comes out in, and whether the sections are recognizable.

Text extraction#

A parser can only work with text it can extract. Word documents and PDFs exported from word processors contain real text. A scanned page, a photo of a resume, or a design export that flattens text into a picture contains pixels, not characters. Turning those into text requires optical character recognition, a separate step that accessibility guides like WebAIM's PDF guide describe as converting a scanned PDF into a searchable file.

Reading order#

This is where most layout problems start. A document stores text in pieces with positions on the page. The parser has to decide the order to read those pieces. In a single column, that's easy. With two columns, a sidebar, or a table, the "right" order is ambiguous.

Researchers at Microsoft describe reading order detection as "the cornerstone" of understanding visually rich documents, and built a dataset of about 500,000 document images to train a model for it (LayoutReader, EMNLP 2021). Modern parsers have improved a lot. But if a research team needed half a million examples to tackle the problem, it's fair to assume not every ATS gets it right on your unusual template.

Section detection#

Parsers look for familiar headings to decide which text is experience, education, or skills. "Experience," "Work Experience," "Professional Experience," "Education," and "Skills" are universally recognized. Creative headings like "Where I've Made an Impact" or "My Toolkit" may not be, and the text under them can end up in the wrong section or nowhere at all.

Entity recognition and normalization#

Inside each section, the parser tries to label each line. Is "Northwind Health" a company or a school? Is "Operations Lead" a title? Is "2021–23" a date range? Consistent patterns make this easy: the same order of title, company, location, and dates for every role, written the same way each time.

The most common resume parsing errors#

Here's a quick reference for the errors you're most likely to see, what they look like, and what causes them. The sections that follow explain each fix in detail.

Layout errors: columns, tables, and text boxes#

Layout is the biggest source of parsing problems because it affects reading order for the entire document.

Two-column layouts and sidebars#

In a two-column template, a parser that reads straight across the page will merge each left-column line with the right-column line beside it. Your skills list gets spliced into your job bullets. Even parsers that detect columns can misjudge where one ends, especially when columns have different lengths.

The fix is a single column for any resume you submit through an online application. If you love the look of a sidebar, keep a designed version for networking, portfolio sites, and in-person handoffs.

Tables used for layout#

Many templates use invisible tables to line up dates on the right or place skills in a grid. Parsers may read table cells row by row, column by column, or skip them. Microsoft's accessibility guidance makes a related point for screen readers: tables used for layout, merged cells, and nested tables make it hard for assistive technology to keep its place (Microsoft Support). Parsers face a similar challenge.

Use right-aligned tab stops to line up dates instead of tables. They look identical on the page and keep the text in a single reading stream.

Text boxes, shapes, and floating elements#

Text boxes sit on a separate layer from the main document text. Some parsers ignore them entirely; others extract them at the end of the document, far from where they appear visually. Never put anything important, especially your name, contact details, or a summary, inside a text box or shape.

A layout risk model#

The chart below is a simple model for thinking about relative risk, based on how each element interacts with text extraction and reading order. The scores are a judgment-based scale, not measured failure rates.

Header, footer, and contact information errors#

Missing contact details are one of the most common and most damaging parsing errors. A recruiter who likes your profile but can't find your email or phone number has to dig for it, and many won't.

Why headers and footers are risky#

Word processors store headers and footers separately from the body text. Some parsers read them, some don't, and some read them in an unexpected order. Microsoft's accessibility guidance advises against putting important information in headers or footers because screen readers may not scan them, and the same caution applies to parsers.

Where to put contact details instead#

Put your contact block at the top of the body of the document:

• Your full name on the first line, as plain text, not as an image or logo
• City and state (a full street address isn't necessary)
• Phone number in a standard format, such as (555) 123-4567
• Email address written out, not hidden behind an icon or link text
• LinkedIn URL or portfolio URL as visible text

For more detail on what to include and what to leave out, see our guide to the resume header.

Icons instead of labels#

Phone, envelope, and pin icons look tidy, but they're images or symbol-font characters with no meaning to a parser. The parser may still find an email by its "@" sign, but phone numbers and locations are easier to miss without context. If you keep icons, make sure the text next to them is complete. Better yet, use short words like "Phone" and "Email," or simply the values separated by vertical bars.

Date and job title errors#

Dates and titles drive some of the most important calculations an ATS makes: your years of experience, your most recent role, and whether your titles match what a recruiter searches.

Date formats that parse reliably#

The key is consistency. A parser that sees five different date styles has five chances to guess wrong.

Write "Present" for a current role rather than leaving the end date blank. Use a plain hyphen or en dash between dates.

Job title and employer order#

Pick one pattern and use it for every role. The most common is title on the first line, then employer, location, and dates. What matters is that the parser sees the same structure each time and can learn where titles sit.

Multiple roles at one company#

Promotions are a common source of title errors. If you stack two titles under one employer without dates for each, the parser may only record the first. Give each title its own line and date range. Our guide to listing multiple positions at the same company shows several clean patterns.

Character, font, and symbol errors#

Sometimes the layout is fine but individual characters break. These errors are small and easy to miss on screen.

Fonts and special characters#

Standard fonts such as Calibri, Arial, Georgia, or Garamond extract cleanly. Decorative and symbol fonts can map letters to unusual code points, so the parser reads your name or bullets as strings of odd characters. If you want a font that's readable for both people and software, see the best resume fonts and sizes.

Bullets and separators#

Fancy bullets such as arrows, checkmarks, or custom images sometimes come through as question marks or boxes. Standard round bullets and hyphens are safest. The same goes for separators between contact details: vertical bars and commas are fine, while special symbols may not be.

Skill bars, charts, and ratings#

A five-dot rating next to "Python" means nothing to a parser. Worse, the skill name itself may sit inside the graphic and disappear. Write skills as text, and if you want to show depth, use words such as "Advanced" or a short proof point in a bullet.

File-type errors: scanned PDFs, image exports, and Word quirks#

Your file format decides whether there's text to parse at all.

Image-only PDFs#

If you scanned a printed resume, took a photo of it, or exported it from a design tool in a way that flattens text, the PDF holds an image. Many parsers will return an empty or nearly empty profile. Some systems handle this gracefully: Greenhouse says candidates whose resumes couldn't be processed are labeled for manual review rather than scored (Greenhouse Support). But you can't count on every system doing that, and an empty profile is a poor first impression.

Word documents#

DOCX files usually parse well, but they carry their own risks: tracked changes left on, comments, embedded objects, and fonts that aren't installed on the employer's side. Accept all changes, delete comments, and stick to common fonts before you send a Word file.

PDF or Word?#

Both work in most modern systems when the file contains real text. If the employer asks for one format, use it. If not, a clean single-column PDF exported from a word processor is a sensible default. For the full trade-offs, read PDF vs. Word for your resume.

Exports from design tools#

Design apps and some online resume builders offer several export options. Depending on the settings, text may be exported as real characters, as vector outlines, or as part of a flattened image. Outlines and images look identical on screen but contain no extractable text. If you designed your resume in a visual tool, run the plain text test on the export. If nothing pastes, change the export setting or rebuild the resume in a word processor.

Other file details that trip up uploads#

• File size. Very large files with embedded images can fail to upload. Keep resumes small by removing photos and graphics.
• File name. It won't break parsing, but people see it. Use something like "Jordan-Lee-Resume.pdf."
• Password protection or restricted copying. A parser can't extract text it isn't allowed to read. Remove all restrictions.
• Unusual formats. Pages, ODT, or image files may not be accepted at all. Convert to PDF or DOCX.

How to test your resume with a resume parser#

You don't need the employer's ATS to catch most problems. Four quick tests, in order, will surface nearly every parsing error.

1. The plain text test. Open your resume, select all, copy, and paste into a plain text editor. Read top to bottom. Every section should appear in order, with nothing missing and no merged lines.
2. The parser preview. Upload the file to a free resume parser and look at each field. Check your name, email, phone, every job title, every employer, every date range, and your degree.
3. The ATS check. Run the file through an ATS resume checker to catch section-heading and formatting issues the parser preview doesn't flag.
4. The live autofill test. Start an application on a site that offers "autofill from resume." Don't submit. Compare each prefilled field with your file.

What each test catches#

How to read the plain text test#

The pasted text tells you a lot if you know what to look for:

• Lines alternate between two topics (a job bullet, then a skill, then a bullet): the parser is reading across columns.
• Your name or contact details appear at the very end, or not at all: they sit in a header, footer, or text box.
• A block of text appears out of place at the bottom: that block is in a text box or floating shape.
• Dates appear on their own lines far from their roles: they're in a separate table column or a right-hand sidebar.
• Boxes, question marks, or odd symbols: a symbol font or a special bullet character didn't extract.
• Nothing pastes at all: the file is image-only.

Each pattern points to a specific fix in the sections above, so you can repair the cause rather than guess.

What a broken parse looks like#

Every error here traces to layout. The contact details were in the document header. The skills sidebar was read across into the experience column. The education section sat next to a long bullet and absorbed it.

How to fix a broken parse: a rebuild workflow#

Patching a broken template one field at a time rarely works, because the underlying structure is the problem. Rebuilding takes about 30 minutes and fixes everything at once.

The rebuild, step by step#

• Start from a blank document or a simple single-column template.
• Paste your content in as plain text to strip hidden formatting.
• Add your contact details as the first lines of the body.
• Use standard section headings: Summary, Experience, Education, Skills, Certifications.
• Format every role the same way: title, then employer, location, and dates.
• Line up dates with right-aligned tab stops instead of tables.
• Use standard round bullets and one common font.
• Export to PDF from the word processor, or save as DOCX if requested.
• Rerun all four tests.

If you build resumes in Google Docs, our Google Docs resume guide covers which template features to avoid. For choosing a template that won't fight you, see how to choose a resume template.

The same resume, parsed after the rebuild#

Parsing pitfalls section by section#

Even with a clean single-column layout, individual sections have their own traps. Here's what to watch in each.

Summary or profile#

Keep the summary as a short paragraph or two to three plain lines under a clear heading such as "Summary." Avoid putting it in a shaded box or a text box at the top, which is a common template feature. Parsers sometimes skip boxed summaries, and some read a heading-less paragraph as part of your contact block.

Experience#

Experience is where reading order and date problems concentrate. Keep each role's header on one or two lines in the same pattern, then bullets. Avoid putting a company description in italics between the header and the bullets if your template treats it as a separate element. If you must describe the company, add a short phrase after the employer name instead.

Education#

Write the degree, the field, the school, and the year in a predictable order: "B.S., Statistics, State University, 2019." Parsers look for degree words such as Bachelor, Master, B.S., or MBA. If you list relevant coursework or honors, put them on a separate line below so they don't merge into the degree.

Skills#

A plain list separated by commas, or a few short labeled lines such as "Analytics: SQL, Python, Tableau," parses reliably. Multi-column skill grids built with tables don't always. Neither do skills inside graphics or tags styled as shapes. For more on structure, see our guide to the skills section on a resume.

Certifications and licenses#

Give certifications their own heading rather than tucking them into education or skills. Write the full name, the abbreviation, the issuer, and the date: "Project Management Professional (PMP), PMI, 2024." License numbers are optional, but if you include one, keep it on the same line as the license name.

What to do when an application form misparses your resume#

Even a clean file sometimes gets misread by a particular system. When the autofilled form is wrong, don't just submit and hope.

Fix the form, field by field#

The form values may be what the recruiter sees in your profile summary, so they deserve the same care as your resume. Correct every job title, employer, and date. Delete duplicate entries the parser created. Fill in anything left blank, especially phone and email.

Keep an application kit#

Typing the same details into dozens of forms is tedious and error-prone. Keep a plain text file with:

• Your contact block exactly as you want it to appear
• Each role's title, employer, city, start date, and end date
• Each degree with school, field, and graduation date
• Certifications with issuer and date
• A short version of your summary and a skills list

Copying from that file into form fields is faster than fixing autofill, and it keeps your details consistent across every application. For portal-specific tips, read our guide to applying through Workday, Greenhouse, Lever, and other portals.

When to skip autofill entirely#

If a form misparses badly, such as merging all your roles into one, it's often faster to clear the fields and enter them manually from your kit. Then still attach your resume file, since many recruiters open the original document.

Do you still need to avoid two-column resumes?#

You'll find confident advice on both sides of this question. Some resume builders argue modern parsers handle columns well. Others say to avoid them completely. Both have a point.

What's changed#

Document AI has improved, and many current parsers detect columns and read them in a sensible order. A two-column resume submitted to a modern system may parse perfectly.

What hasn't changed#

You usually can't know which parser an employer uses or how old it is. A layout that parses cleanly in one system can scramble in another. And the human read matters too: a Ladders eye-tracking study reported by HR Dive found multiple columns and cluttered layouts performed worse with recruiters, while simple layouts with clear headings held attention.

A decision table#

If you work in a creative field, see when creative resumes help and when they hurt. Everyone else can get a clean, professional look in a single column, as our guide to ATS-friendly resume formatting shows.

Next steps: test, fix, and keep a clean master file#

Parsing errors are among the easiest resume problems to fix once you can see them. The trick is to look. Here's what to do now:

• Run the plain text test on your current resume today.
• Upload it to a parser preview and check every field, especially titles and dates.
• If anything is scrambled, rebuild in a single column rather than patching.
• Save the clean version as your master file so every tailored version starts from a structure that parses.
• Run a full resume checker pass for clarity and impact once the structure is sound.

After that, your time is better spent on content. Read ATS myths to drop the tricks that don't work, and use what an ATS score means to tune each application. Resume Maker exports single-column files built to parse cleanly, but whichever tool you use, test the output before you apply.