ATS Resume Formatting Rules That Pass the Bots

By Diane Pruett, Lead Career Strategist · Updated June 26, 2026 · ~40 min read

Why formatting decides the outcome

There is a particular kind of heartbreak in a job search that has nothing to do with your qualifications. You're a strong candidate. Your experience is exactly what the role needs. You apply, and you hear nothing. After the tenth silent rejection you start to wonder whether a machine is throwing your resume away before a single human lays eyes on it. The honest answer, after twelve years and more than ten thousand resumes across my desk, is this: a machine rarely rejects you outright, but a machine very often mangles you. And a mangled resume is functionally invisible. The recruiter searching for your skills doesn't find you, or pulls you up and sees a jumble, and moves on. The cause is almost never your content. It's your formatting.

That's the uncomfortable, liberating truth at the center of this guide. The applicant tracking system — the ATS, the software that sits between you and the company's recruiter — is not a judge handing down a verdict. It's a filing system. Its entire job is to take the file you upload, pull the words out of it, and slot those words into a structured database so a human can search and sort the pile later. When your formatting cooperates, the parser files you accurately and you turn up in every search you should. When your formatting fights it, the parser drops your job titles into the wrong field, scrambles your work history, or finds no readable text at all, and you simply never surface. Same person, same achievements, two completely different outcomes, decided entirely by how the document was built.

This is why formatting is the highest-leverage thing you can fix in an afternoon. You can't change your years of experience this week. You can't conjure a new degree. But you can stop your resume from self-destructing on contact with the software, and that single change can be the difference between silence and a calendar full of conversations. Throughout this guide I'll keep the focus narrow and practical: not vague "be ATS-friendly" platitudes, but the specific, concrete formatting decisions — column count, heading text, font choice, date style, file type — that determine whether you parse clean. For the broader strategy of keywords, accomplishment bullets, and tailoring, see our companion ATS resume guide; here, we go deep on formatting alone.

The three failures behind "the bots rejected me"

When a member arrives at Marqee convinced an algorithm has been quietly discarding them, we almost always trace the silence to one of three concrete formatting failures, not to a secret rejection robot. Naming them precisely is the first step to fixing them.

• The invisible resume. Some part of the document — sometimes the whole thing — is an image rather than text. The parser extracts nothing, so the candidate is filed as a near-empty record and never matches a search. This is the most catastrophic and the most common among people who built their resume in a design tool.
• The scrambled resume. The text extracts, but a two-column layout, a layout table, or a floating box has shuffled it. The candidate's title might land under the wrong employer, or skills end up spliced into a sentence about a past job. They surface in some searches but read as incoherent when opened.
• The misfiled resume. The text is clean and in order, but creative headings or a header-zone contact block mean key fields are blank or wrong. The candidate has no captured email, or their experience is dumped into a generic bucket that tenure filters ignore.

None of these is a judgment on the person. Each is a mechanical consequence of how the document was built, and each is fixable in minutes once you can see it. The rest of this guide is, in effect, a systematic way to make all three impossible.

How a parser actually reads your file

To format for a parser, it helps to know what the parser is doing under the hood, not the proprietary details of any one system, but the shared mechanics that every modern parser relies on. When you upload a document, the software performs a sequence of steps, and your formatting can help or sabotage each one. Understanding the sequence turns abstract rules into obvious common sense.

First, the parser extracts the raw text. It reads the file's internal text stream, the actual characters stored in the document, and produces a flat string of words. If your text is real, embedded, selectable text, this step is trivial. If your "text" is actually an image of text (a scanned page, a design-tool PNG, a logo with your name baked in), there is nothing to extract and the parser sees a blank where your qualifications should be. This is the first place formatting either works or fails completely.

Second, it establishes reading order. The parser has to decide the sequence in which to read the page's elements. Most do this top to bottom, and many do it left to right across the full page width before dropping down a line. This is the step that two-column layouts break: when a parser reads across a row that spans both columns, your sidebar and your main column get woven together into nonsense. The reading-order step is also why floating text boxes, tables, and overlapping elements cause trouble: they don't sit cleanly in a single linear flow.

Third, it segments the text into sections by looking for headings it recognizes. When it sees "Work Experience," it knows the lines beneath belong in the experience field; "Education" triggers the education field, and so on. This is why heading text matters so much. A heading the parser doesn't recognize doesn't trigger a field, so the content beneath it gets dumped into a generic bucket — or lost.

Fourth, it maps the segments to structured fields — name, email, phone, employer, title, dates, skills — and stores that structured record in the database. From that point on, you exist in the system as a set of fields, and recruiters search and filter against them. Everything you do in formatting is in service of making these four steps go smoothly. The figure below shows the pipeline; every rule in this guide attaches to one of these stages.

It's worth pausing on what this mechanism does not include. There is no step where the software reads your resume for quality, assigns a holistic "fit score," and silently bins anything below a cutoff. The persistent claim that a large majority of resumes are auto-rejected by bots before any human sees them is folklore with no credible source behind it. A small number of high-volume employers use knockout questions on the application form — "Are you authorized to work here?", "Do you have a required license?" — and some use ranking features that help a recruiter sort, but those are aids to a human decision, not a silent guillotine. The takeaway for formatting is liberating: you are not trying to outwit a hidden judge. You are trying to be read accurately by a filing system and clearly by the person who searches it. That's a solvable, mechanical problem, and formatting is the solution.

This also reframes what "passing the ATS" really means. You don't pass by hitting a keyword quota or fooling an algorithm. You pass by being extractable (your text comes out as text), orderable (it comes out in the right sequence), recognizable (your sections map to the right fields), and findable (your titles, skills, and dates land where searches look). Every formatting rule in this guide serves one of those four properties. Keep them in mind and each rule stops feeling like arbitrary superstition and starts feeling like obvious engineering.

Columns: the single biggest break

If you fix only one thing after reading this guide, fix this. The two-column resume — a narrow sidebar of skills, contact details, or a skills-bar graphic running down one side, with your experience in a wider column beside it — is the most common and most destructive formatting mistake I see. It looks polished and modern on screen, which is exactly why people choose it and exactly why it does so much damage. The visual elegance hides a parsing catastrophe.

Here's the mechanism. Many parsers don't perceive your two columns as two columns; they read the page as a sequence of horizontal lines spanning the full width. So when the parser reaches a horizontal band that contains both your sidebar's "Python" and your main column's "Senior Analyst at Northwind Corp, led a team that...", it reads them as one continuous line. The result is a scrambled interleaving: your skills get spliced into the middle of your job descriptions, your contact details land in the wrong place, and your beautifully designed resume becomes word salad in the database. A recruiter searching for "Senior Analyst" might still match, or might not, if the title got chopped, but when they open your record, the parsed view is incoherent.

The fix is simple and total: use one column, top to bottom, for everything. Stack your contact line, summary, skills, experience, and education vertically, in that single flow. The parser then reads exactly the sequence you wrote, and reading order is preserved. As a bonus, single-column resumes are also faster for a human to skim (the eye runs straight down the page instead of bouncing between columns) so you lose nothing and gain reliability on every system. There is no design benefit worth the risk; I have never once seen a two-column layout outperform a clean single column in real outcomes.

Sections & headings the ATS recognizes

Once the parser is reading your page in the right order, the next thing it does is look for headings it recognizes so it can sort your content into the correct fields. This is where a surprising number of otherwise-clean resumes lose information, not because the content is weak, but because the labels above it are too clever. A parser is a literal creature. It knows "Work Experience" means your jobs. It does not know that "Where I've Left My Fingerprints" or "The Road So Far" means the same thing, so it can't trigger the experience field, and your hard-won history gets dumped into a generic catch-all or dropped from the searchable record entirely.

The rule is to keep your headings conventional and boring, and save every drop of personality for the bullets beneath them. Here are the standard headings parsers reliably recognize, and the creative variants to avoid.

Two further heading rules matter. First, make headings visually distinct but textually plain — bold and slightly larger is perfect; the parser reads the words, and the human reads the emphasis. Second, don't merge sections under one heading. A combined "Experience & Education" heading confuses the field mapping; give each its own standard label so each triggers its own field. The goal is a resume whose skeleton a parser could reconstruct blindfolded, purely from the heading text.

A frequent question is whether headings can be styled at all, and the answer is yes, generously, as long as the underlying text stays standard. Bold them, set them a couple of points larger than the body, add a thin rule beneath, give them a touch more space above than below so each visually opens a new block. All of that is parse-safe because the parser reads the words "Work Experience," not the formatting around them. What you must not do is replace the words with a graphic banner, an icon, or an abbreviation the parser won't recognize. "EXP." is not "Experience" to a literal matcher; spell it out. The same caution applies to bilingual or stylized headings: if you're applying in an English-language market, the recognized English label should be present even if you add a translation.

Section order & the top third

Formatting isn't only about what the parser can read; it's also about what the human reads first. A recruiter's initial pass on a pulled-up resume lasts roughly six to eight seconds, and their eye starts at the top and works down. Whatever sits in the top third of page one carries the weight of the entire first impression. So the order of your sections is a formatting decision with real consequences, and the right order depends on where you are in your career.

The default order (most people)

1. Contact line — name, location, phone, email, LinkedIn, all as plain text.
2. Professional summary — three or four lines naming your target title, top skills, and one headline result.
3. Skills — a compact, comma-separated text line of genuine, role-relevant capabilities.
4. Work experience — reverse-chronological, most recent first, with quantified bullets.
5. Education — degree, institution, year.
6. Optional sections — certifications, projects, languages, as relevant.

Formatting the skills section specifically

The skills section deserves its own note because it's where graphics most often sneak in and where parse-safe formatting pays off directly in searches. Format it as a compact block of plain, comma-separated text — nothing else. If it's long, group it with simple text labels ("Languages: Python, SQL, R · Tools: Tableau, Looker, dbt · Certifications: AWS, Scrum"), still as plain text on plain lines. Resist every temptation to dress it up: no proficiency bars, no star ratings, no rings, no color-coded tags, no two-column grid of skills. Each of those turns a searchable list of keywords into an unreadable graphic, and the skills section is precisely the part recruiters search hardest. Keep it boring and textual and it becomes your most reliable source of matches. And remember the pairing principle: every important skill listed here should also appear, proven, inside an experience bullet, so the parser finds the term and the human finds the evidence.

When to reorder

New grads and students move Education above experience, since your degree, coursework, and projects are your strongest evidence. Career changers lean on the summary and a Projects or transferable-skills section near the top to reframe relevance before the dated history. Senior leaders and executives may open with a brief leadership summary and let scope (budgets, headcount, regions) sit in the top third. Whatever your situation, the principle is constant: the most relevant, most impressive material belongs where the eye lands first. Don't make a recruiter dig to page two for the reason to call you.

Fonts, sizes & spacing

Font choice rarely gets a resume rejected on its own, but it can quietly cause two problems: a downloaded display font that fails to embed and renders as garbled glyphs when parsed, and text so small or so tightly spaced that the human gives up. Both are formatting failures dressed up as style. The cure is to be unremarkable in the best way.

Choosing a font

Use a common, system-standard font, one that ships on essentially every computer, so it's guaranteed to render and embed. Standard sans-serifs (the clean, modern look) and the classic serifs (a more traditional, formal feel) are all safe. Avoid three categories: decorative or script fonts that are hard to read and may not embed; novelty display fonts downloaded from design sites; and ultra-thin "light" weights that can disappear at small sizes or when printed. Pick one font for the whole document — at most one for headings and one for body — and stick with it.

Sizes and spacing that read well

Bold is your friend: it's parse-safe and helps the human eye find your titles and your numbers. Italics are fine in moderation. What to avoid is relying on color, underlines, or all-caps to carry meaning, since they add visual noise without adding parse value, and heavy all-caps runs are slower to read. The look you're aiming for is calm, legible, and confident — a document that respects the reader's eight seconds.

Sans-serif or serif — does it matter?

Practically, no — both parse identically, so the choice is purely about the impression you want to make on the human. A clean sans-serif reads as modern, efficient, and is the default for technology, design, and most corporate roles. A classic serif reads as traditional, established, and can suit law, finance, academia, and senior or formal contexts. Either is correct; what matters is that you pick one widely available typeface and use it consistently. The mistake isn't choosing the "wrong" family; it's choosing a downloaded display font that may not exist on the recruiter's machine or embed in the file, in which case the system substitutes something else and your careful layout shifts or, worse, your glyphs garble on extraction. When in doubt, the safest fonts are the ones you didn't have to install.

Bullets, dashes, and special characters

Use your word processor's real bullet character for list items rather than hand-typing asterisks, hyphens, or decorative wingding glyphs; real bullets are recognized cleanly, while ornamental symbols occasionally garble on extraction. For date ranges, a simple hyphen or en-dash is safe; avoid fancy typographic flourishes between dates. Smart quotes and standard accented characters are generally fine on modern systems, but if your name or a credential uses unusual diacritics and you want to be cautious, run the paste test (described later) to confirm they survive. The principle throughout is the same: the more standard and unremarkable each character is, the more reliably it travels from your document into the database.

Headers, footers & contact placement

This is the most overlooked formatting trap, and one of the most damaging: putting your contact details (or anything important) inside the document's header or footer region. In a word processor, the header and footer are special zones that repeat at the top and bottom of every page. They're perfect for page numbers in a report. They are a liability on a resume, because a number of parsers skip those regions entirely when extracting text. The consequence is brutal: your name, email, and phone number, sitting neatly in the page header, simply don't make it into the database. You become a strong candidate with no way to be contacted, filed under a blank name.

The rule is absolute: keep every piece of contact information, and everything else that matters, in the main body of the document. Put your name on the first line of the body as ordinary text, then a line with your city and state, phone, professional email, and your LinkedIn URL written out. No header zone, no footer zone, no text box. The very top of the body is also the right place visually, since it's the first thing both the parser and the human encounter.

Tables, text boxes & graphics

Three formatting devices feel helpful and are quietly toxic to parsing: tables used for layout, floating text boxes, and graphics standing in for text. They share a root problem: they break the simple, linear, real-text flow that parsers depend on.

Tables used for layout

Designers love tables for alignment — a tidy grid putting skills in neat columns, or job titles on the left and dates on the right inside invisible cells. The trouble is that some parsers read table cells in an unexpected order, or merge them, so your carefully aligned content scrambles. A single-column resume can still hide a layout table inside it. The safe approach is to lay out skills as a plain comma-separated text line and to align dates with a tab or a right-aligned tab stop, not a table column. Reserve real tables for nothing — your resume doesn't need one.

Text boxes and shapes

A text box is a floating container that sits on top of the page rather than in its text flow. Parsers frequently skip them. If your summary, a "key skills" callout, or your contact block lives in a text box, it may never be read. Everything important must be in the normal document flow — ordinary paragraphs and lists — not in a floating box or shape.

Graphics, icons, and skill bars

This is the cardinal rule of parse-safe formatting: if it isn't real text, the parser can't read it. A skills bar chart, a five-star rating beside "Excel," a circular progress ring for "Spanish," a logo containing your name, an icon replacing the word "email," or an entire resume exported as an image from a design tool — all of it is invisible to the parser. Replace every graphic with text. Write "Advanced" or "Fluent" instead of filling in stars; write your name as text, not inside a logo; spell out "Email:" instead of using an icon. And skip the headshot in most markets — it carries no parseable value and can invite bias.

Dates the parser can read

Dates seem trivial, but the parser does something specific and fragile with them: it reads your employment dates to compute tenure and to order your roles. When date formatting is inconsistent or non-standard, the parser miscalculates how long you held a role, mis-orders your history, or fails to recognize a current job — all of which weaken your record in tenure-based searches and confuse the human reading next.

The safe format is plain, spelled, and consistent: "Jan 2022 – Mar 2026," with the month spelled or clearly abbreviated and the full four-digit year. Use the word "Present" for a current role rather than leaving the end open. And, this is the part people miss, use the exact same format on every single entry. A resume that mixes "2022–2026," "Jan '22 - now," and "January 2022 to Present" forces the parser to guess, and guessing is where tenure breaks.

One more date detail: place the date on the same clear line as the job title and employer, or immediately beside it with a tab, not in a separate column or table cell. The parser wants to see "Title — Employer — Dates" as a recognizable unit so it can bind them together. Consistency here pays off invisibly: when every role follows the same pattern, the parser computes your experience correctly and you appear accurately in "X years of experience" filters.

Ordering and overlap

List roles in reverse-chronological order (most recent first) because that's the order both parsers and recruiters expect, and it puts your strongest, most current evidence in the top third. If you held two roles at once (a promotion, a concurrent contract), give each its own dated line rather than trying to merge them into one entry with a confusing combined range; the parser handles two clean entries far better than one ambiguous one. For a promotion within the same company, you can list the company once with two dated title lines beneath it, as long as each title and its dates sit on a clear, recognizable line. The guiding question for any date decision is simply: can the parser tell where each role started and ended, and in what order? If yes, you're safe.

Length, whitespace & the one-page myth

Length is where formatting anxiety and parsing reality part ways most sharply. The popular rule — "a resume must be one page" — is a human-readability convention, not a parsing constraint. The parser does not care whether your resume is one page or three; it reads the whole text stream regardless. Length never blocks a parser. So the real question isn't "how do I fit one page" but "how long should this be for the human," and the honest answer depends on your experience.

The formatting failure here isn't being too long; it's shrinking a naturally two-page career onto one page by dropping the font to 9 points and the margins to a sliver. That's harder to read, signals an inability to prioritize, and gains you nothing with the parser. A clean, well-spaced two pages always beats a suffocating single page. The opposite failure is also real: padding a thin history with filler to "fill the page." Relevance, not length, is the target. Put your strongest material in the top third, keep what earns its place, and let the page count fall where it naturally lands.

Whitespace is a formatting tool, not wasted space

New job seekers often treat empty space as an enemy to be eliminated. In truth, whitespace is what makes a resume scannable in eight seconds. Consistent spacing between sections, a blank line before each heading, comfortable margins, and bullets that breathe all guide the recruiter's eye to your strongest points. A wall of dense text (even perfectly parseable text) exhausts the human and buries your wins. Treat whitespace as deliberate formatting: it costs you a little room and buys you a great deal of attention. If trimming whitespace is the only way you can hit one page, that's your signal to go to two.

File type, naming & the apply form

The last mile of formatting is the file itself, and a few small choices here decide whether all your careful structure survives the upload. There's a persistent myth that PDFs always break the ATS; it's wrong, but with an important nuance.

PDF vs. Word

A text-based PDF — one exported directly from a word processor, where the text is real and selectable — parses cleanly on essentially every modern ATS and has the advantage of locking your layout so it looks the same to every human. This is the safe default. The problem PDFs are image-based ones: a scanned page, or a resume exported as an image from a design tool, where the "text" is actually a picture. Those contain nothing to extract. The simple test is the cursor again: open your PDF and try to select the text. If you can, it's text-based and safe; if you can't, it's an image and will fail.

Send .docx when the application form specifically requests Word format, since some older or specialized systems prefer it, and you should always follow the form's instruction. A clean, single-column .docx parses just as reliably as a text-based PDF. What you should never submit: a scanned image, a .pages file (not universally supported), a screenshot, or a link to an online resume in place of the file.

File naming

Name the file clearly and professionally: Firstname-Lastname-Resume.pdf, or add the role — Maya-Rivera-Marketing-Manager-Resume.pdf. A clear name is easier for a recruiter to find in a folder of hundreds and signals care. Avoid resume-final-v3-REALLY-final.docx and generic document.pdf.

The apply form itself

Many systems ask you to upload and then auto-fill an application form from your resume, sometimes asking you to confirm or correct the parsed fields. When that happens, treat it as a free preview of how the parser read you. If the auto-filled work history is scrambled or your title landed in the wrong box, that's a direct signal your formatting needs work, so fix the resume, don't just patch the form. And if a form lets you paste a plain-text version, paste a clean one; it's another path into the searchable record.

A field guide to what breaks parsing

Let's consolidate. Below is the full catalog of formatting choices that scramble, drop, or hide your information, ranked roughly by how often I see them sink an otherwise-strong resume. If you audit your own resume against just this table, you'll catch the overwhelming majority of parsing problems before they cost you a single application.

The subtle edge cases worth knowing

Beyond the headline breakers, a handful of subtler traps catch otherwise-careful resumes. None is as destructive as a two-column layout, but each can quietly cost you a field or a match.

• Acronyms without their spelled-out form. A recruiter might search "Certified Public Accountant" or "CPA." Include both once — "Certified Public Accountant (CPA)" — so either literal string matches. This is a formatting habit as much as a keyword one: the pairing has to physically appear as text.
• Hyperlinks with no visible address. A LinkedIn link hidden behind the words "my profile" survives only as those words once the formatting is stripped. Write the readable URL — "linkedin.com/in/yourname" — so the address itself is real text in the body.
• Right-aligned dates via tab vs. table. Aligning dates to the right margin with a tab stop is parse-safe. Achieving the same look with a two-cell table or a separate text frame is where order scrambles. The visual result is identical; the parse result is not.
• Section dividers and decorative rules. A thin horizontal rule between sections is fine. Heavy graphical dividers, repeated symbol strings, or image separators can introduce stray characters or confuse segmentation. Keep dividers simple or skip them.
• Color as the only signal. If a skill's proficiency is conveyed only by the color of its text or a colored dot, that meaning is invisible to the parser and to anyone reading a black-and-white print. Carry every meaning in words.
• Embedded objects. Charts pasted from a spreadsheet, SmartArt diagrams, or embedded images of certificates are objects, not text. State the same information in a plain line and attach certificates separately if a form requests them.

The reassuring thing about every item above is that the same five-second paste test, covered later, catches all of them at once. You don't have to memorize the list; you have to run the test.

Before & after: formatting fixes

Principles land when you see them applied. Below are three real-pattern formatting fixes — the kind our strategists make daily — focused purely on structure and presentation rather than wording. Same person, same facts; the only change is how the document is built.

Example 1 — The designer's two-column resume

What changed: nothing about the person, only the container. The sidebar collapsed into the single column, the dot-rating graphics became words, and the icon-only contact became plain text in the body. Now every field extracts correctly.

Example 2 — Contact details hidden in the header

What changed: a five-second move out of the header zone turned an uncontactable record into a complete one. This single fix has reconnected more strong candidates than almost any other in my experience.

Example 3 — Inconsistent dates and a layout table

What changed: removing the layout table and standardizing the date format let the parser bind each title to its employer and dates, compute tenure accurately, and order the history correctly, so the candidate now matches "5+ years" filters they were silently missing.

A copy-paste, parse-safe skeleton

Here's a single-column, standard-headed, plain-text-friendly skeleton you can copy into a blank document and fill in. It embodies every formatting rule in this guide. Replace the bracketed prompts, keep the structure, and you've eliminated the formatting failures that quietly cost interviews. For deeper help on the wording inside each bullet, pair this with our ATS resume guide and resume optimization service.

[FULL NAME]                              ← line 1, body, largest text
[City, ST] · [Phone] · [you@email.com] · linkedin.com/in/[handle]

SUMMARY
[Target title] with [X] years in [field]. Skilled in [skill 1],
[skill 2], and [skill 3]. [One headline result with a number].

SKILLS
[Skill], [Skill], [Skill], [Tool], [Tool], [Methodology], [Cert]
(plain comma-separated text — no bars, stars, or icons)

WORK EXPERIENCE
[Job Title] — [Company], [City, ST]            [Mon YYYY – Mon YYYY]
- [Strong verb] [what you did], [quantified result]
- [Strong verb] [what you did], [quantified result]
- [Strong verb] [what you did], [quantified result]

[Job Title] — [Company], [City, ST]            [Mon YYYY – Present]
- [Strong verb] [what you did], [quantified result]
- [Strong verb] [what you did], [quantified result]

EDUCATION
[Degree], [Institution]                                    [YYYY]

CERTIFICATIONS  (optional, high-value in regulated fields)
[Exact credential name] — [Issuing body], [YYYY]

Notice what this skeleton does and doesn't do. It uses one column. It uses the five standard headings. Dates are spelled and consistent, on the same line as the title and employer. Skills are plain text. There are no tables, no text boxes, no graphics, no header zone. Saved as a text-based PDF named Firstname-Lastname-Resume.pdf, it will parse cleanly on essentially every modern system — and read clearly to the human on the other side.

Testing your formatting in 5 minutes

You don't need special software to know whether your resume will parse. You need two quick tests you can run yourself in five minutes, plus a note on the score-checker tools.

The paste test (the one that matters)

1. Open your resume. Select all (Ctrl/Cmd-A) and copy.
2. Open a plain-text editor — a bare notes app or a blank document set to plain text.
3. Paste, and read it top to bottom.

This is the closest thing to seeing your resume through the parser's eyes. If the order is correct, nothing is missing, your contact details are present, and it reads coherently as plain text, the parser will read it the same way. If columns are interleaved, your name is gone, or skills are scrambled, you've found your formatting problem before it cost you an application. This single habit catches nearly everything in the field guide above.

The cursor / select test

Open your PDF and try to highlight your name, one skill, and one date with your mouse. If you can select them as text, they're real text and the parser can read them. If your cursor won't grab them, they're an image, and they're invisible to the ATS. Run this on any resume you exported from a design tool.

On third-party "ATS score" checkers

Online tools that paste in your resume and a job description and return an "ATS score out of 100" can be a useful nudge; they'll often flag a missing keyword or a formatting red flag. But treat the number with healthy skepticism: those tools use their own invented rules, not the actual parser a given employer runs, so the score is not a verdict. Use them to catch obvious formatting issues and keyword gaps; don't reformat your life around hitting an arbitrary percentage. The paste test is a better, truer signal than any score.

Special cases: visas, gaps & international

A few situations raise formatting questions of their own. The good news: the core rules don't change; you just apply them with a little extra care.

Employment gaps

Parsers handle year ranges fine, so a gap won't "break" anything mechanically. The formatting move is to keep dates plain and consistent across every entry (including any gap-filling line like a contract, caregiving period, or study), so tenure computes cleanly, and to address the gap in one honest line in your summary or as a brief dated entry. Don't try to disguise a gap with vague or graphical dates; that creates a parsing problem on top of a human one.

Visa status and international talent

If work authorization is relevant, state it as plain text, a short, clear line such as your authorization status, rather than burying it in a graphic or a sidebar. Knockout questions on the application form may also ask about authorization directly; answer those honestly. For region-specific norms, remember that some markets expect a photo or additional personal details on a "CV" while others (and most ATS-driven markets) prefer none; mirror the local convention, but never put required text inside an image. Our guidance for visa & international talent covers the wider playbook.

CV vs. resume by market

In some countries the document is called a CV and runs longer, with sections like publications or a personal statement. The formatting rules still apply: single column, standard headings, real text, plain dates, a text-based file. Length is fine where the market expects it — what matters for parsing is structure, not page count.

Names, diacritics, and address lines

If your name uses accented characters or a script the system may not handle gracefully, the formatting rule is to keep it as real text (never an image) and to run the paste test to confirm it survives extraction intact. Most modern parsers handle standard diacritics fine, but the test removes all doubt. On addresses, a city and region are enough for parsing and for the human; a full street address adds no parse value and is best omitted for privacy. If a role is location-sensitive, a short, plain line stating your location or willingness to relocate reads cleanly and answers the question the recruiter is silently asking.

Career returners and non-linear histories

If you're returning to work after time away, or your path includes contracts, freelancing, or portfolio work, the formatting goal is to make each period legible as a dated, recognizable entry rather than a gap the parser has to infer. Give a contract or a returnship its own clean title-employer-dates line. List freelance or portfolio work under a standard heading like "Experience" or "Selected Projects" with dated entries. The parser then computes a continuous, coherent history, and the human sees a story rather than a question mark. The structural discipline does double duty: it satisfies the machine and reassures the reader.

The pre-submit formatting checklist

Run this every time, right before you upload. It takes under five minutes and catches the formatting failures that silence strong candidates.

When formatting isn't the bottleneck

Here's the honest part most resume guides won't tell you. You can do everything on this checklist perfectly — single column, clean text, ideal dates, a flawless text-based PDF — and still hear nothing. Why? Because clean formatting gets you read; it doesn't get you chosen, and it certainly doesn't get you past the brutal math of the front door. When hundreds of qualified people apply to the same posting through the same form, parsing perfectly just earns you a place in a very large, very even pile. Formatting is necessary. It is rarely sufficient.

The candidates who actually break through tend to arrive a different way. Instead of dropping a resume into the same portal as everyone else and waiting, they get their materials in front of a human directly — through a recruiter who already knows the role, or through a referral from someone inside the company. A resume that comes in warm, attached to a name a hiring manager trusts, is read in a completely different frame than the four-hundredth upload of the day. That's the side door, and it's where most real interviews come from. The front door is where resumes go to be counted; the side door is where candidates go to be remembered.

This is exactly the work Marqee does on a member's behalf, and it's why we're a human-led service rather than a formatting tool. A real strategist finds the roles that fit, tailors your resume and materials to each one (parse-perfect, every time), and then does the part that actually moves the needle: recruiter outreach and referral discovery, getting you in front of the people who decide, not just the software that files you. We submit on your behalf so your energy goes into interviews, not application forms. Your strategist works quietly behind the scenes to find roles and surface connections faster; the judgment, the writing, and the relationships are theirs. We can't and don't promise outcomes (no honest service can) but we can promise that you'll stop being a stranger in a pile and start being a name people recognize.

To be clear about where formatting sits in that bigger picture: it's the price of admission, not the prize. A parse-perfect resume guarantees you're filed and findable, which means that when a strategist's outreach prompts a recruiter to look you up, or a referral lands your resume on a hiring manager's desk, the document they pull holds together and reads well. Bad formatting can squander even a warm introduction: a referrer's effort is wasted if the resume they forward parses into nonsense in the company's system. So the formatting discipline in this guide isn't in tension with the side-door strategy; it's the foundation that makes the side door pay off. Get the document right first, then get it in front of the right people. That sequence — clean materials, then human-led outreach — is the whole method, and it's what a free 48-hour Pro trial is designed to let you feel before you commit to anything.

The deeper reason we lead with humans is that the parts of a job search that actually change outcomes are stubbornly human: knowing which roles are real and worth your time, reading between the lines of a posting, writing a message a busy recruiter will answer, and finding the one person inside a company who'll vouch for you. No amount of formatting cleverness substitutes for those. What formatting does is remove the self-inflicted wounds — the invisible resume, the scrambled record, the blank contact field — so that the human work has a clean foundation to build on. Fix the formatting yourself with this guide, and you've already done the part that's purely mechanical. The rest is where a strategist earns their keep.

Frequently asked questions

Keep reading: The complete ATS resume guide (keywords, bullets & tailoring) · Interview prep questions · Job-search metrics that matter · More from the Marqee blog.