DEV Community

Emmanuel Gendre
Emmanuel Gendre

Posted on Edited on

A Tech recruiter's 5-level framework to write your resume bullet points

Resumes that consistently land job interviews win on technical content.

Yet, most of the resume bullets I screen stop at the task ("Tested a web application."), without mentioning engineering techniques, tools and or metrics. But in an ultra-competitive job market where recruiters have the luxury of choosing between many qualified profiles, you need to provide more proof than your competition.

I was a recruiter for years, before founding TechieCV and rewriting 1,500+ resumes as a tech resume writer. When starting the resume service, I needed a reliable and repeatable way to assess and measure bullet points against. So I built this "Level System".

It's 5 questions you ask yourself, with each one adding a layer of technical detail.

If you're currently working on your resume, use the steps below as a step-by-step guide to rewrite each of your bullet points. You're going to be amazed at the result ;-)

Ready?

Let's one simple bullet through all five levels. The sample is a back-end task: making a shop's product list load faster by keeping copies of common answers ready, which engineers call caching.

1. What task did you work on?

Why it matters: This is the base layer. A resume whose bullets stop here gets rejected. Still, you can't add detail until you know which duty a bullet covers.

How:

  • Write one bullet per duty listed in your job description.
  • Drop pronouns. No "I", no "my team".
  • Use the past tense, even for your current job. The bullet should read as something you finished.

Example:

Built a caching layer for a product catalog API.

2. What techniques did you use?

Why it matters: At Level 1, the recruiter only knows you "did some caching". At Level 2, they see which techniques you actually have experience with.

How: List the specific techniques inside the task. Spell out any abbreviation once, with the short form in parentheses. Recruiters are often less technical than you, and they may search for either version ;-)

Example:

Built a caching layer for a product catalog API, using read-through caching and write-time invalidation.

3. What tools did you use?

Why it matters: Recruiters at competitive companies search candidate databases by typing long lists of specific tool names.

A bullet that only describes the task won't match, so you don't show up in their results. Each tool you list is also one more keyword for the applicant tracking system (ATS), the software that filters resumes, to match.

How:

  • Add the main tools for the task.
  • Add the setup around them too: the programming language and the database.
  • These secondary tools show the hiring manager the setup you worked in.

Example:

Built a Go caching layer for a PostgreSQL-backed product catalog API, using Redis for read-through caching and write-time invalidation.

(Go is the language, PostgreSQL the database, Redis the cache.)

4. Which methodology/best practice did you follow?

Why it matters: Teams follow set methods for how they work. The hiring manager, the person who makes the hire, usually picks those methods and makes sure people follow them. Listing yours shows you care about how the work gets done.

How: Find the framework, process or theory behind the duty. Even duties that feel simple have one. Sales has SPIN selling or consultative selling. Presentations have storytelling techniques. In engineering, think Test-Driven Development (TDD: writing tests before the code), Domain-Driven Design (DDD: shaping code around the business it serves) or Service Level Objectives (SLOs: speed or uptime targets the team commits to).

Example:

Built a Go caching layer for a PostgreSQL-backed product catalog API against a p99 Service Level Objective (SLO), using Redis for read-through caching and write-time invalidation.

5. How did you measure results, and what were they?

Why it matters: A number shows your actual impact. More importantly, it shows you cared enough to measure it. Hiring managers value that habit more than the size of the number, especially for juniors.

How:

  • Pick one metric: the one that measures the outcome most directly. For a testing program, that's how many bugs reach users, not how much code the tests cover. Three numbers compete with each other, and the recruiter remembers one.
  • Keep it in the same sentence, as a closing phrase: "cutting X", "reducing X".
  • Stay under three lines.
  • No number available? Use a qualitative result, such as recognition from management.

Example:

Built a Go caching layer for a PostgreSQL-backed product catalog API against a p99 Service Level Objective (SLO), using Redis for read-through caching and write-time invalidation, cutting p99 latency from 850ms to 120ms.

p99 latency is the wait time for the slowest 1% of requests.

The work is the same as in step 1. The bullet now tells the recruiter what you did, how, with which tools, under which method, and what it changed.

The checklist

1. State the duty you worked on, past tense, no pronouns.
2. Add the techniques you used, abbreviations spelled out.
3. List every tool, including language and database.
4. Add the methodology or framework behind the work.
5. Close with one metric, or a qualitative result.
Enter fullscreen mode Exit fullscreen mode

Every layer you add gives a recruiter one more reason to say yes.

This leaves two questions open: how many bullets each job needs, and which metrics count as strong in your kind of role.

I answer both in the bullet-point writing guide, , with 10 before and after bullets for engineering, data and cloud roles.

It also links to reference numbers for common metrics and the skills lists recruiters search for.

Top comments (0)