Video summary

Why New Grad Software Engineers CAN'T Get Interviews | Recruiter Reviews Resumes EP 125

Main summary

Key takeaways

Business

Business/job-search performance takeaways (execution-focused)

Core diagnosis

Entry-level candidates underperform because they submit non-targeted, generalized resumes and fail to communicate job-title/stack-specific proof in ATS-friendly formatting.

Target outcomes (benchmarking)

  • Current observed ratios: ~1 interview per 100 applications (entry-level “D minus”).
  • Desired improvement: ~1 in 50 (ideal; “C minus” in normal markets).
  • Hard-market target: ~1 in 40 to 1 in 50.
  • Another observed case: ~1 in 75 (“C minus” / passes but can improve).

Frameworks / “playbooks” implied for resume optimization

Resume specialization playbook (software engineering)

  • Break resumes by job title + stack (e.g., full-stack vs front-end vs back-end).
  • If focusing on back-end, specialize further (e.g., Java vs Python vs C).
  • If applying across roles: create 3 separate resumes (not one generalized version).

Bullet-proofing playbook (ATS + recruiter scan)

  • Replace vague bullet formatting with “what / how / why” sentences.
  • Put keywords where the reader can find them quickly—don’t force the reviewer to scroll forever.
    • Keywords must appear early and clearly.

Formatting standard (ATS + readability)

  • Use a clean template:
    • Name/contact on top
    • Education in one line
    • Minimal technical-skill clutter
  • Bold only:
    • Section headers (e.g., education/certificates; work/projects section titles)
    • Avoid bolding random keywords/numbers.

Job-application throughput playbook

  • ATS may prioritize order (stated: sorting by application order, not pure keyword matching).
  • Therefore, apply quickly when openings appear.
  • IT roles can fill fast (sometimes within a day or two).

Concrete resume/process recommendations (software engineering)

1) Targeting & structure

  • Repeated problem: applying with a generalized resume or unclear job focus (e.g., “they didn’t tell me what kind of software engineer”).
  • Action: pick your target stack and tailor keywords accordingly:
    • Example stacks mentioned: front-end / back-end / full-stack
    • For back-end sub-focus: Java or Python or C/Cobalt

2) What gets recruiters to interviews (employment + projects)

  • Hiring manager priorities: employment and projects, not a long technical skills list.
  • Action: write project/employment bullets where keywords appear naturally.
    • Example “good sentence pattern”:
      • “Developed the backend using Node.js, Express, and MongoDB … implementing secure … RESTful endpoints.”
  • Even if some terms (e.g., Express) don’t function as strict ATS keywords, the bullet must still include the right technology + outcome verbs + relevant phrasing.

3) Keywords checklist for full-stack (US-targeted list)

Use a recruiter-specified keyword set and ensure they appear in the resume text (not only in colored regions):

Core

  • TypeScript, Python, JavaScript, CSS, HTML, Node, Angular, Next.js
  • MongoDB, SQL, React.js
  • API, REST
  • Cloud, Agile, CI/CD
  • cross-functional

Bonuses

  • architecture
  • extra language

4) Common failure modes

  • Too many technical skills listed: can be interpreted as “lying” or not meaningful.
  • Bad bullet formatting: keywords placed too deep/scattered; bullets too vague.
  • Colored/red “keyword lists” don’t count: must be shown in context.
  • Keyword misuse: tools like Lambda/Athena/S3/ETL may be irrelevant depending on the role; wrong keywords can hurt matching.
  • Formatting issues reduce keyword capture:
    • Education placement can disrupt scanning order
    • Excessive line breaks/structure can make ATS/reviewers miss key content

Concrete examples from reviewed resumes (software engineering)

  • Resume #1 (entry-level)

    • Issue: incorrect role targeting (“software engineer” but no clear specialization); bullets buried; technical section irrelevant; inconsistent bullet structure.
    • Good sign: at least one well-written project sentence (e.g., HTML/CSS/JS project bullet).
    • Result: ~1 interview / 100 applications → “D minus” (but close to recoverable).
    • Fix emphasis: rewrite bullets using the “good sentence” style; specialize to a stack; clean formatting.

  • Resume #2 (~1 in 75)

    • Strength: decent bullet quality; better formatting.
    • Issue: still not focused enough; bullet formatting needed to be more consistent.
    • Notable project: real-time music streaming platform (“architected and implemented…” with specific technologies).
    • Fix emphasis: keep strong bullets, but enforce stack focus and ATS-friendly formatting; avoid confusing recruiter language (e.g., “leveraging” criticized; some terms like WebRTC not understood).

  • Resume #3 (full-stack attempt with “updated resume”)

    • Prior ratio: ~1 in 300 (not working).
    • Issue: missing “how/why with outcomes” structure; incorrect/insufficient keyword presence; cloud tooling may reflect wrong role focus.
    • Fix emphasis: reduce “keyword dumping,” correct full-stack keyword relevance, and ensure keywords appear early.

  • Resume #4 (re-submission)

    • Formatting guidance expanded (font sizes, bold rules).
    • Issue: missing ~60–70% of expected full-stack keywords in searchable/early sections; incorrect bolding; insufficient coverage (~30–35%).
    • Fix emphasis: elevate key keywords (JS/HTML/CSS/etc.), use “what/how/why,” and reach ~75% keyword alignment.

Concrete resume recommendations (admin/executive assistant—process and KPIs)

Application volume KPI

  • Example: admin assistant candidate applied to ~70 jobs since January, but recruiter flagged it as not enough sample size.
  • Recommended throughput: ~50 applications per week.

Spelling/grammar KPI

  • For admin/executive assistant roles, spelling errors can cause rejection (more sensitive than for software roles).

Role translation tactic

  • Internal title differences can work, but only if duties align and you can explain it in the interview.

Formatting + section order

  • Education should be near the top (for most resumes).
  • Remove unnecessary sections (avoid irrelevant summaries/expertise blocks).
  • Combine employment entries into one coherent work-history structure.

Bullet focus KPI

  • Current bullets are ~50% of what’s needed; aim for ~75%.
  • Increase emphasis on:
    • calendar management
    • setting up meetings
    • travel arrangements
    • multitasking
    • attention to detail

High-level actionable checklist (derived from the reviews)

  • Pick one target: job title + stack (front-end vs back-end vs full-stack; then specific backend language).
  • Use separate resumes if applying to different job titles.
  • Rewrite bullets in “what/how/why” format and ensure keywords are in main readable sections (not colored text or buried).
  • Remove noise: shrink technical skill lists; delete irrelevant summaries/projects sections as needed.
  • Follow formatting rules: clean template; education one line; bold only section headers/certificates.
  • Increase application throughput:
    • Software: apply quickly (roles can fill fast)
    • Admin: aim for ~50/week
  • Target metrics goal: improve from ~1/100 toward ~1/50 (or 1/40–1/50 in a tough market).

Presenters / sources

  • Headless Head Hunter (corporate recruiter) — presenter reviewing the resumes.

Original video