We Broke Our Own Resume Parser on Purpose
One resume, rendered five ways, run through our real extraction pipeline. The same document scored 98 as pasted text and 67 as a PDF — and the most useful finding was the one where the score stayed perfect and the text was scrambled anyway.
CareerDiary is our product, and the parser in this study is ours. We are publishing our own bugs — the checker is free either way.
What we found
- Not one word was ever lost. Across every format and both generations of our parser, the extracted word count was 159 — identical to the source, every time. Nothing was dropped and nothing was invented.
- The structure was destroyed instead. A 25-line resume came out of our old PDF extractor as a single line. Every downstream check is line-oriented, so bullet detection found 0 of 9 and the score fell from 98/A to 67/C.
- Word's bullets are frequently not “•” at all. Symbol-font bullets arrive as Private Use Area codepoints like U+F0B7. A resume identical in every way except the font its bullets were drawn in scored 67/C against a pasted 98/A.
- And the finding we did not expect: our two-column fixture scores 98/A today — a perfect result — while the text it scored has a degree welded to a job's start date. A clean score is not proof of a clean parse.
Method
The document. One synthetic resume for a fictional senior backend engineer — 159 words, 9 bullets, 25 lines. It is generated deterministically from a single source of truth, so every rendering below contains byte-identical text. No real person's resume was used.
The five renderings. Plain text (the baseline), a single-column PDF, a two-column PDF whose sidebar deliberately shares horizontal bands with the main body, a PDF whose bullets are drawn in a Symbol font carrying the character mapping that produces Private Use Area codepoints, and a Word .docx. The PDFs are emitted by a hand-written generator rather than a layout library, because the thing under test is line reconstruction from glyph coordinates — so the fixture has to control the exact position of every run of text.
The pipeline. pdf.js (pdfjs-dist) 5.4.449 for PDFs and mammoth 1.8 for Word — the same extraction path that runs in your browser when you use our free checker. Scores come from runAtsScan() — the same deterministic engine behind our free checker.
The comparison. We ran every fixture through two generations of the pipeline: the code as it stood on 2026-08-09, and the code as it stands today. Both sets of numbers on this page were measured on 2026-08-16 by checking out each commit and re-running.
Provenance. The defects were fixed in 2d3e7992 (2026-08-10) and 9b48695c (2026-08-10). Both are deployed. The numbers rendered on this page are re-derived from the committed fixtures by a test in our suite, so if the parser changes and this page does not, the build goes red.
Results
Before — the pipeline as it stood on 2026-08-09
Highlighted row is the pasted-text baseline. Every other row is the identical document in a different container.
| How it was handed over | Score | Grade | Bullet impact | Bullets found | Words | Lines |
|---|---|---|---|---|---|---|
| Pasted plain text | 98 | A | 100 | 9 | 159 | 25 |
| Single-column PDF | 67 | C | 30 | 0 | 159 | 1 |
| Two-column PDF | 67 | C | 30 | 0 | 159 | 1 |
| PDF with Symbol-font bullets | 67 | C | 30 | 0 | 159 | 1 |
Every PDF collapsed to a single line, so bullet detection found nothing and the bullet-impact score sat at its floor of 30. The .docx is absent from this table because it could not be read at all in a browser — the upload rejected outright.
After — the pipeline today
| How it was handed over | Score | Grade | Bullet impact | Bullets found | Words | Lines |
|---|---|---|---|---|---|---|
| Pasted plain text | 98 | A | 100 | 9 | 159 | 25 |
| Single-column PDF | 98 | A | 100 | 9 | 159 | 25 |
| Two-column PDF | 98 | A | 100 | 9 | 159 | 19 |
| PDF with Symbol-font bullets | 98 | A | 100 | 9 | 159 | 25 |
| Word .docx | 98 | A | 100 | 9 | 159 | 25 |
- Single-column PDF: Recovered line-for-line.
- Two-column PDF: Same score — but 19 lines, not 25. The columns are interleaved. See below.
- PDF with Symbol-font bullets: Bullets arrive as U+F0B7, never as “•”, and are still read as bullets.
- Word .docx: Before 2026-08-10 this upload failed outright in the browser.
A real two-column mis-parse
This is not an illustration. The right-hand column is quoted verbatim from what our current extractor returned for the two-column fixture — the same run that scored 98/A. Both sides are excerpts around the same part of the document.
What the document says
EXPERIENCE
Staff Software Engineer, Northwind Systems
January 2021 - Present
• Led migration of 40 microservices to Kubernetes, cutting deploy time 62%
• Reduced p99 API latency from 840ms to 210ms by rewriting the caching layer
EDUCATION
B.S. Computer Science, University of Washington, 2016
SKILLS
Python, TypeScript, Go, Kubernetes, …Long lines are not wrapped — scroll sideways to read them in full.
What the extractor stored
linkedin.com/in/alexmorgan EXPERIENCE
EDUCATION Staff Software Engineer, Northwind Systems
B.S. Computer Science January 2021 - Present
University of Washington, 2016 • Led migration of 40 microservices to Kubernetes, cutting deploy time 62%
SKILLS • Reduced p99 API latency from 840ms to 210ms by rewriting the caching layer
Python • Architected an event pipeline processing 12M events per day on Kafka
TypeScript • Mentored 6 engineers, 3 of whom were promoted within 18 monthsLong lines are not wrapped — scroll sideways to read them in full.
Read the third line on the right: “B.S. Computer Science January 2021 - Present”. The degree and the job's start date are now one line, because in the source PDF they sit at the same height on the page — one in the sidebar, one in the body. A reader working from coordinates has no unambiguous way to know they are unrelated. Our extractor does not try to guess column order, on the grounds that guessing wrong is worse than being predictable; the score survives because bullet detection tolerates a bullet appearing anywhere in a line rather than only at its start.
The three defects, in detail
1A PDF has no lines, and we were not rebuilding them
What the code did: A PDF stores glyphs at coordinates, not lines of text. Our extractor joined every run of glyphs with a space, so a 25-line resume came out as a single 159-word line. The fix reconstructs lines from the glyph coordinates: group by baseline, and insert a space only where the page has a real gap — so a kerned “Kub” + “ernetes” stays “Kubernetes” instead of becoming two words.
What it cost: Every line-oriented check downstream had nothing to work with. Bullet detection found 0 of 9, and the bullet-impact score fell to its floor of 30. Score 98 → 67, an A to a C.
Why it matters to you: Nothing was missing from the text. All 159 words were there in every single run we measured. What was destroyed was the structure — and structure is what a parser turns into fields.
2Word bullets are often not the “•” character at all
What the code did: Symbol-class fonts — Symbol, Wingdings, OpenSymbol, which are Word's default list bullets on several export paths — have no real Unicode mapping. Extractors emit their glyphs into the Private Use Area instead, so a bullet authored in Word arrives as U+F0B7 and never as “•”. We now match the whole U+F000–U+F0FF block rather than folding those codepoints back, because Word's other default bullets fold onto ordinary letters: U+F06C becomes “l”, U+F0A7 becomes “§”, U+F0FC becomes “ü”.
What it cost: A resume whose only difference was the font its bullets were drawn in scored 67/C against a pasted 98/A — after the line-reconstruction fix had already shipped.
Why it matters to you: This one is invisible. The document looks identical on screen and prints identically. The difference exists only in the file, which is exactly the class of problem you cannot proofread your way out of.
3The .docx upload path was broken in browsers only
What the code did: The library we use to read .docx swaps in a different unzip implementation for browsers, and only that one accepts the input shape we were passing. Every browser upload rejected with “Could not find file in options”. Node accepted the old shape, so an end-to-end test passed while every real upload failed.
What it cost: A .docx upload could not be scanned at all in a browser. We now assert against the library's browser module directly, so the environment that actually runs the code is the one under test.
Why it matters to you: File-format support is not a yes/no property of a system. It can be true in one environment and false in another, which is why “it worked when I tested it” is weak evidence about a pipeline you cannot see.
What this means if you're job hunting
A good score is not proof of a good parse
Our two-column fixture scores 98/A — identical to the pasted baseline — and its stored text still welds a degree to a job's start date. The score was computed on text that had already been scrambled. This is the finding we did not expect, and it is the one worth carrying: a checker that reports a number is not the same as a checker that shows you the text it scored.
One column is the cheapest insurance you can buy
Two columns are not "banned" and nothing auto-rejects them. The problem is narrower and more mundane: when a sidebar shares a horizontal band with the main body, a coordinate-based reader has no unambiguous way to know which one continues the sentence. Ours interleaves them. A single-column layout has no ambiguity to resolve.
Read the text back, not the PDF
Copy your own resume out of the PDF and paste it into a plain text editor. That approximation of what a parser sees takes about fifteen seconds and catches interleaved columns, merged lines, and mangled bullets — the same three things this study found.
Boring section headers are doing real work
EXPERIENCE, EDUCATION, SKILLS. Our extractor recovered those headers on every rendering, and they are the anchors that make the surrounding structure legible. Creative substitutes throw away a signal that costs you nothing to keep.
The failure mode is silent by design
In every run we measured, the word count was 159 — before the fixes and after, in every format. Nothing was dropped and nothing was invented. A parse can be badly wrong while every word is still present, which is why this is not something you can catch by re-reading your resume.
Unlimited, no signup. The scan runs entirely in your browser — your resume text is never uploaded. The one optional AI rewrite sends a single bullet point, and only if you ask for it.
Limitations
What this study does not show. We would rather you discount it correctly than over-trust it.
N is one resume, in five renderings
This is a controlled stress test, not a survey. We built one synthetic resume and rendered it five ways specifically to isolate failure modes we suspected. It tells you that these failures are real and exactly what they do. It tells you nothing about how often they occur in the wild, and we make no such estimate.
We tested our own parser, not any employer's
The subject here is CareerDiary's text-extraction pipeline — pdf.js and mammoth, as we use them. We did not test Workday, Greenhouse, Lever, Taleo, or any company's internal system. Those vendors do not publish their parsers and we have no access to them. Anyone claiming to have benchmarked them is guessing.
The document is synthetic and adversarial
The fixture PDFs are hand-built so we control the exact coordinates of every run of text — that is the whole point, since coordinate reconstruction is what is under test. The two-column fixture deliberately shares horizontal bands between the sidebar and the body, which is the hard case. A real two-column resume may be laid out more forgivingly, or less.
The scores are our scorer's opinion
The 98s and 67s come from our own deterministic scoring engine. It is consistent and it is transparent about what it rewards, but it is one opinion about resume quality, not an industry standard. The score movements matter here because they are measuring structural damage; the absolute numbers are not a grade any employer will give you.
Reading order for multi-column layouts is out of scope for us
Our extractor deliberately does not attempt to resolve column reading order — a two-column resume has genuinely ambiguous order, and guessing wrong is worse than being predictable. We compensate downstream by treating bullet glyphs as evidence anywhere in a line rather than only at its start, which is why the two-column fixture still scores correctly despite its text being interleaved.
The fixtures live in a private repository
We can and do re-run this on demand — the study's numbers are asserted by a test suite that reads the committed fixtures, so the page cannot drift from the parser. But the repository is not public, so you cannot clone it and reproduce this yourself today. We would rather say that plainly than imply an openness we have not shipped.
One thing we will not do is put a percentage on this. You will find claims that a specific share of resumes are filtered out before a human sees them; no ATS vendor publishes such a figure, and we have not measured one. This study is one document in five renderings. It shows that a failure mode is real and demonstrates exactly what it does — which is a smaller claim than a rate, and the largest one the evidence supports.
Questions about this study
What exactly did you test in this resume parsing study?
One synthetic resume, rendered five ways: pasted plain text, a single-column PDF, a two-column PDF, a PDF whose bullets are drawn in a Symbol font, and a Word .docx. We ran each through our own text-extraction pipeline (pdf.js (pdfjs-dist) 5.4.449 for PDFs, mammoth 1.8 for Word) and scored the extracted text with the same deterministic engine that powers our free checker. The fixtures are committed and the numbers on this page are asserted by a test suite, so the page cannot drift from what the parser actually does.
Does this tell me how Workday or Greenhouse will read my resume?
No, and we want to be blunt about that. We tested our own parser. Workday, Greenhouse, Lever, Taleo and every employer's internal system are closed — they do not publish their parsers and we have no access to them. What this study shows is that the class of failure is real and mechanical: a document that looks perfect can extract into scrambled text. Whether any specific employer's system has the same weaknesses, we cannot say, and neither can anyone else who has not been given access.
So what percentage of resumes get filtered out by parsing errors?
We do not know, and we will not guess. The widely repeated figures about resumes being auto-filtered before a human sees them are not published by any ATS vendor. This study is one document in five renderings — it establishes that a failure mode exists and shows exactly what it does, which is a different and more modest claim than a rate. Anyone quoting a percentage should be asked where it came from.
Should I avoid two-column resume templates?
If you want the safest option, yes — one column removes an ambiguity rather than gambling on how it gets resolved. But the honest version is narrower than the usual advice: nothing auto-rejects a two-column layout. The issue is that when a sidebar shares a horizontal band with the main body, a coordinate-based reader has no unambiguous way to know which one continues the sentence. Our extractor interleaves them, which you can see in the side-by-side example above.
How can I check my own resume for this?
Two ways, and the first is free and takes fifteen seconds: copy the text out of your own PDF and paste it into a plain text editor. What you see is a rough approximation of what a parser gets, and it will show you interleaved columns and merged lines immediately. Second, run it through our free checker, which reports the structural signals — bullets found, section headings recognised, and keyword coverage against a specific job description.
Is this checker really free with no signup?
Yes. The scan is unlimited and runs entirely in your browser — no account, no email, no scan cap. A free account only adds extras: fixing every weak bullet with AI, tailoring to a specific job, and score history.
Is my resume uploaded or stored anywhere?
No. The scan is computed locally in your browser — your resume text is never uploaded, stored, or used for training. If you choose the optional AI sample rewrite, only that single bullet point is sent for processing.
Ready to Get Started?
Use CareerDiary to tailor your resume to each role and keep your job search organized — free to try, no account needed.
Get Started Free - No Credit Card Required