All posts

4 min read

A resume applicant tracking systems can read

Why a two-column resume filed bullets under the wrong jobs in its PDF text layer, and the CI check that now proves every bullet stays under its own heading.

My resume PDF looked perfect and read wrong. On screen every job sat in a neat row: title and dates on the left, bullets on the right. In the file's text layer, which is the only part an applicant tracking system reads, it said something else entirely.

An applicant tracking system, or ATS, is the software most employers use to collect applications. It turns each resume into searchable fields (jobs, dates, skills) before a recruiter ever opens the file, so if it reads yours wrong, a person may never see it.

Here is how mine got read wrong, and the check that stops it happening again.

What an ATS actually reads

An ATS does not look at your PDF. It extracts the text, in the order the file stores it, and then guesses at structure: a line that looks like a heading starts a section, and everything after it belongs to that section until the next heading.

That second rule is the whole problem. A bullet is filed under the nearest preceding heading in the text stream, not under the heading it sits beside on the page.

How two columns broke it

Take a made-up resume with two jobs:

Output
Staff Engineer · Larkspur Analytics        2022 to now
  - Designed team-level permissions for organizations and projects
  - Cut the p95 dashboard load from 4s to 900ms

Senior Engineer · Tidewater Studio         2018 to 2022
  - Built the billing service behind seat-based plans

Each job was a flex row: a fixed left column for the title and dates, a flexible right column for the bullets. Chromium's print pipeline does not promise to emit text in visual order, and for this layout it emitted the left column's text for a block, then the right column's. The extracted text came out closer to this:

Output
Staff Engineer · Larkspur Analytics 2022 to now
Senior Engineer · Tidewater Studio 2018 to 2022
Designed team-level permissions for organizations and projects
Cut the p95 dashboard load from 4s to 900ms
Built the billing service behind seat-based plans

Read that the way an ATS does. Every bullet now follows the Tidewater heading, so the parser credits the newer job's work to the older one and leaves the current role with nothing under it. Nothing about the PDF looks wrong. You cannot catch this by opening the file.

The fix is a linear layout

The layout rule that came out of it is short:

  • No side-by-side columns that wrap multi-line content. A job's heading, then its dates, then its bullets, in that order in the markup.
  • No absolutely positioned list markers. A marker placed out of flow can land in the text stream away from its line.
  • Keep each job's block together with break-inside: avoid, so a page break never separates a heading from its first bullet.

That brings the text stream back in line with the reading order. But a rule nobody checks is a rule that quietly breaks on the next redesign, so the real fix is the test.

Testing the reading order in CI

The resume is a normal page on the site, and the PDF is generated from it with Playwright rather than exported by hand. The same script then reads the generated file back with pdf.js and asserts its order. Three choices make that check worth trusting.

Expectations come from the rendered page, not a hard-coded list. Each job's container carries a data attribute, so the test asks the page what it should find:

HTML
<div data-resume-job="Larkspur Analytics" class="break-inside-avoid">
  <h3>Staff Engineer · Larkspur Analytics</h3>
  <ul>
    <li>Designed team-level permissions for organizations and projects</li>
  </ul>
</div>
JavaScript
const jobs = await page.$$eval("[data-resume-job]", (els) =>
  els.map((el) => ({
    heading: el.querySelector("h3").textContent,
    firstBullet: el.querySelector("li").textContent,
  })),
);

Add a job, rename one, reorder them: the test follows, because it never had its own copy of the resume to drift from.

The comparison ignores everything but letters and digits. PDF extraction joins wrapped lines without a space and renders dashes and bullets inconsistently, so the test reduces both sides to bare alphanumerics first. Ordering survives that, and ordering is all it is asserting.

JavaScript
const squash = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");

The search only ever moves forward. A title like "Senior Engineer" can repeat across employers, so searching from the top every time would find the first one for all of them. Instead a cursor advances through the text: find this job's heading after the previous match, then require its first bullet after that heading and before the next job's heading.

JavaScript
let cursor = 0;
for (const [i, job] of jobs.entries()) {
  const at = text.indexOf(squash(job.heading), cursor);
  const next = jobs[i + 1]
    ? text.indexOf(squash(jobs[i + 1].heading), at)
    : text.length;
  const bullet = text.indexOf(squash(job.firstBullet), at);
  if (at < 0 || bullet < 0 || bullet > next) {
    throw new Error(`${job.heading}: its bullets are not under its heading`);
  }
  cursor = at;
}

The same run fails if the resume goes past two pages, which is the other mistake you cannot see until a recruiter scrolls.

Keeping the committed file honest

The PDF is committed so the site can serve it. A second check regenerates it and compares the result with the committed copy, so the download can never fall behind the page.

It compares extracted text, not bytes. Chromium rasterises fonts slightly differently on each platform, so a PDF built on Linux is never byte-identical to one built on Windows, even with the same content. A byte comparison would fail in CI forever and prove nothing.

What I took from it

The failure was invisible in every view I had of the file, which is exactly why it needed a test. If something you ship is read by a machine, test what the machine reads. For a resume that is the text layer, in order, and the check is a few dozen lines.

The resume this check guards is the one linked from every page of this site.

Want the work behind the notes?

The projects show the same habits in code you can open and run.