What a resume is for and who reads it

Canada’s Job Bank tells job seekers that employers spend 30 seconds on average skimming a resume, and an eye-tracking study by the job-search company Ladders measured an average first screen of 7.4 seconds. In that time a resume has to earn a longer read, and once it has, it becomes the page your interviewers prepare their questions from.

This lesson follows one application past each of its readers, measures how much of page one a first screen can reach, and separates a resume from two documents that share its names. You will be able to say what each reader needs from your page, and to decide what goes in its first lines.

A resume has two jobs: earn the conversation, then steer it

Asha Verma, a backend engineer with three years of experience and the invented candidate this track follows, lists Kubernetes among her skills because she once followed a tutorial. The line helps her through the first screen. In the second interview the interviewer reads it out and asks how she rolled back a failed deployment, and she has nothing to say. The line that won the screen has cost her the round.

Those are the two jobs of a resume. The first is to earn the next conversation: Google calls the resume “our first look into your past experiences and impact”. The second starts once you are invited, because the people who interview you read the resume to choose their questions. In Atlassian’s engineering interview guide the hiring manager conversation centres on one or two of your past projects, the people involved and the technical hurdles, and Google’s interview advice tells candidates to collect examples wherever their resume overlaps the job description. The same line does both jobs, as the table shows:

Write every line so that you could talk about it for five minutes: what you did, why, how you measured it and what you would change now. That is MySmartCoPilot guidance, and it follows from the second job. Microsoft’s careers pages make the honesty side explicit: the expectation of an honest account of yourself covers the resume as much as the interviews.

Four kinds of reader see an application, in turn

Most applications meet the same readers in the same order, although employers merge and skip steps. Step through Asha’s application from the upload to the interviews; each step says who reads it and what that reader decides:

The first reader is software. An applicant tracking systemapplicant tracking system: Software an employer uses to receive applications, store resumes, fill candidate profiles from them, search them and move candidates through the stages of hiring. More in “How applicant tracking systems really work” stores the file, copies details such as the name and the jobs into profile fields, and makes the text searchable. Greenhouse, one such system, documents that a resume it cannot read this way “has only been attached to the candidate”, and that someone then types the details in by hand. The form’s answers come next, and rules can reject an application on one answer alone; the next lesson shows how those rules work.

The first person is usually a recruiter, who checks the fit with the posting: Google asks applicants to make sure their resume clearly shows the role’s minimum qualifications, and Microsoft says a team may follow its resume review with a brief screening conversation. Then the hiring managerhiring manager: The person who leads the team a new hire would join. They read applications for depth and share in the decision to hire. reads for depth, and each interviewer reads the page again before their round. Each reader needs something different from the same page:

• The tracking system needs text it can read, in sections it can recognise.
• The recruiter needs the posting’s requirements in plain sight, near the top.
• The hiring manager and the interviewers need lines with substance: what you built, how big it was, what changed.

A first screen reaches only the top of page one

How long does the first person spend? Canada’s Job Bank puts the average skim of a resume at 30 seconds, and cites no study for it. Ladders reported an average first screen of 7.4 seconds in its 2018 eye-tracking study, against 6 seconds in its previous one, and the report gives no sample size. Treat both numbers as a direction, not a measurement: the first read is short.

A short read covers few words. A meta-analysis of 190 studies puts the average silent reading rate of adults at 238 words a minute for English non-fiction, so 7.4 seconds is about 29 words and 30 seconds about 119. The program reads two versions of the top of Asha’s resume at that rate, a biodata-style page and a focused one:

# How far down the page a first screen gets. Two versions of the top of one invented resume are read at 238 words a
# minute, the average silent reading rate of adults for English non-fiction (Brysbaert, 2019), for the two screen
# times this lesson quotes: 7.4 seconds (an eye-tracking study by Ladders) and 30 seconds (Canada's Job Bank).
# Real screens skim instead of reading every word, so treat each result as the reach of a careful reader.
# Press Edit, paste the top of your own resume into MINE and run it again.
import re

WORDS_PER_MINUTE = 238
SCREENS = [7.4, 30]
# A measured result: a number followed by a unit of what changed.
RESULT = re.compile(r"\d[\d,.]*\s?(?:ms|%|minutes|hours|services|users|rows)\b")

BIODATA_STYLE = """\
BIO-DATA
Name: Asha Verma
Father's name: (her father's name)
Date of birth: (her date of birth)
Religion: (her religion)
Marital status: Single
Career objective: To work in a challenging and growth-oriented environment where I can use my skills for the growth of the organisation.
Educational qualifications: B.Tech. Computer Science, Example Institute of Technology, CGPA 8.2/10
Experience: Software Engineer at Example Logistics
"""

FOCUSED = """\
Asha Verma · Backend engineer · Pune · asha.verma@example.com · github.com/asha-verma-example
Backend engineer, three years of Python and PostgreSQL services; cut p95 API latency from 420 ms to 180 ms.
Software Engineer, Example Logistics, Pune, 2023 – present
- Moved 14 services to Docker and Kubernetes, so a deploy takes 9 minutes instead of 40.
"""

MINE = ""  # the top of your resume, one line per line of the page


def words_of(text):
    """The words of a text: separators such as "·" and "-" are not words."""
    return [w for w in text.split() if re.search(r"\w", w)]


def first_result(words):
    """The position (1, 2, …) and text of the first measured result, or None."""
    for i in range(len(words)):
        found = RESULT.match(" ".join(words[i:i + 2]))
        if found:
            return i + 1, found.group(0)
    return None


def report(name, text):
    words = words_of(text)
    result = first_result(words)
    print(f"{name} ({len(words)} words). First measured result: {f'word {result[0]}, {result[1]!r}' if result else 'none'}.")
    for seconds in SCREENS:
        reach = min(int(WORDS_PER_MINUTE * seconds / 60), len(words))
        tail = " ".join(words[max(0, reach - 8):reach])
        if result and result[0] <= reach:
            verdict = "the result is read"
        elif result:
            verdict = "the result is not reached"
        else:
            verdict = "no result to judge"
        print(f"  {seconds:>4} s reads {reach:>3} words, ending '…{tail}': {verdict}")
    print()


for seconds in SCREENS:
    print(f"In {seconds} s a reader at {WORDS_PER_MINUTE} words a minute gets through {int(WORDS_PER_MINUTE * seconds / 60)} words.")
print()
report("Biodata-style version", BIODATA_STYLE)
report("Focused version", FOCUSED)
if MINE.strip():
    report("Your version", MINE)

In 7.4 s a reader at 238 words a minute gets through 29 words.
In 30 s a reader at 238 words a minute gets through 119 words.

Biodata-style version (61 words). First measured result: none.
   7.4 s reads  29 words, ending '…Single Career objective: To work in a challenging': no result to judge
    30 s reads  61 words, ending '…CGPA 8.2/10 Experience: Software Engineer at Example Logistics': no result to judge

Focused version (49 words). First measured result: word 22, '420 ms'.
   7.4 s reads  29 words, ending '…420 ms to 180 ms. Software Engineer, Example': the result is read
    30 s reads  49 words, ending '…a deploy takes 9 minutes instead of 40.': the result is read

In 7.4 seconds the biodata-style version shows a heading, the name, four personal details and the first words of a career objective, and nowhere in its 61 words is there a result anyone could judge. The focused version reaches its first measured result, “420 ms”, at word 22, inside the 29. Real screens skim rather than read every word: the recruiters in the Ladders study scanned job titles and the left side of the page, which is why bold titles and short bullets help. Either way, the first lines of page one carry the decision. To measure your own, press Edit, paste the first lines of your resume between the quotes of MINE and run the program: it says at which word your first measured result appears.

A resume, a CV and a biodata are different documents

A UK employer asking for a CV and a US employer asking for a resume want the same document. Two other documents share these names but not their purpose, and sending one of them by mistake shows a reader the wrong things:

The lengths come from MIT’s careers office, which describes resumes as typically one to two pages and an academic CVacademic CV: A curriculum vitae for teaching and research posts: a complete record of research, teaching, publications and presentations, which grows longer with a career. as two to four pages for a younger professional and four to seven with more experience. It also notes that in some countries “CV” is used for every kind of application, and the EU’s own format, Europass, is a CV. Canada’s Job Bank asks you to limit a resume to two pages, and the UK’s National Careers Service lists the sections of a job CV: contact details, an introduction, education, work history and references.

Which document to send is the employer’s decision, not yours. Google, for one, says it has no length requirement and does not require cover letters. Another employer, a portal or a college placement office may set its own rules, and those win over any general advice, this track’s included.

Practise: keep a line, give it when asked, or leave it out

Fifteen lines from a biodata-style page are waiting to be sorted. Decide for each one whether it belongs on the resume, is given only when the employer asks, or has no place in an application; the sample tests check each group against the official guides of this lesson:

CATEGORIES = ("resume", "when-asked", "leave-out")

LINES = {
    "name": "Asha Verma",
    "email": "asha.verma@example.com",
    "city": "Pune",
    "github": "github.com/asha-verma-example",
    "date-of-birth": "Date of birth",
    "fathers-name": "Father's name and occupation",
    "religion": "Religion and community",
    "height": "Height and weight",
    "marital-status": "Marital status: single",
    "objective": "Career objective: to work in a challenging and growth-oriented environment",
    "latency": "Cut p95 API latency from 420 ms to 180 ms with PostgreSQL indexes",
    "degree": "B.Tech. Computer Science, Example Institute of Technology, 2022",
    "references": "References: two professors, with their phone numbers",
    "notice-period": "Notice period: 30 days",
    "identity-number": "National identity number",
}


def decide():
    """Return {line id: "resume", "when-asked" or "leave-out"} for every line in LINES."""
    # Replace this line with your decisions.
    return {}

from decide import CATEGORIES, LINES, decide


def test_every_line_has_a_decision():
    """decides every line of LINES, with one of the three categories"""
    decisions = decide()
    assert set(decisions) == set(LINES)
    for line_id, category in decisions.items():
        assert category in CATEGORIES, line_id


def test_contact_details_stay():
    """keeps the name, the city, the e-mail and the GitHub link on the resume"""
    decisions = decide()
    for line_id in ("name", "city", "email", "github"):
        assert decisions[line_id] == "resume", line_id


def test_evidence_stays():
    """keeps the measured result and the degree on the resume"""
    decisions = decide()
    assert decisions["latency"] == "resume"
    assert decisions["degree"] == "resume"


def test_personal_attributes_go():
    """leaves out the date of birth, marital status, religion, height and weight (the official guides)"""
    decisions = decide()
    for line_id in ("date-of-birth", "marital-status", "religion", "height"):
        assert decisions[line_id] == "leave-out", line_id


def test_family_identity_and_objective_go():
    """leaves out the family details, the identity number and the objective that names no skill or result"""
    decisions = decide()
    for line_id in ("fathers-name", "identity-number", "objective"):
        assert decisions[line_id] == "leave-out", line_id


def test_references_and_notice_wait():
    """gives the references and the notice period only when the employer asks"""
    decisions = decide()
    assert decisions["references"] == "when-asked"
    assert decisions["notice-period"] == "when-asked"

Then test the four ideas of this lesson, one question at a time; the idea you have answered worst so far comes up first:

Interview questions

Warm-up (fresher to mid-level): What is a resume for, beyond getting you shortlisted?

It has two jobs. The first is to earn the next conversation: a recruiter reads the top of page one against the posting’s requirements, often for well under a minute, so the strongest evidence has to be there. The second job starts once you are invited, because the interviewers read the resume to choose their questions. Every line is therefore a promise that you can explain it in depth: what you did, how you measured it and what you would change. A good resume is one where a screener finds the fit in seconds and an interviewer finds five minutes of substance behind each line.

An interviewer may follow that answer with two questions of their own. Choose the reply you would give, and read why the others fall short:

Two questions of this module’s bank put both jobs to work:

Key takeaways

• A resume earns the next conversation and then becomes the script of the interview, so every line must be one you can explain in depth.
• An application meets software first, then a recruiter, a hiring manager and the interviewers, and each needs something different from the same page.
• A first screen is short: at 238 words a minute, 7.4 seconds covers about 29 words and 30 seconds about 119, so the first lines of page one carry your strongest evidence.
• A resume, called a CV in many countries, is neither an academic CV nor a marriage biodata, and the employer decides which document it wants and in what form.