# How to Tailor Your Resume (CV) to a Job Description

> Tailor your resume (CV) to a job description in six steps, with a worked engineering example, a copy-paste ChatGPT prompt and a free open-source tool.
- **Author**: Saurabh Rai
- **Published**: 2026-04-10
- **Modified**: 2026-10-17
- **URL**: https://resumematcher.fyi/blog/how-to-match-your-resume-to-a-job-description/

---

You find a posting for a role you can do, send the same resume you sent to the last ten postings, and hear nothing back. A recruiter working through a long queue skims each file, and software has ranked the pile before she opens it. A resume (CV) written for no job in particular loses with both readers.

Tailoring fixes that. You keep one complete master resume, read each job description with intent, and produce a version that describes work you did in the employer's own vocabulary. The method below works with a text editor, with Claude or ChatGPT, or with [Resume Matcher](/docs/what-is-resume-matcher/), the open-source tool I maintain.

## Why you tailor a resume to each job description

Two readers see your resume, and both reward alignment.

The first is a parser. Many companies route applications through an applicant tracking system (ATS), which extracts the text from your file, pulls out skills and titles, and lets recruiters filter and sort on them. If the posting asks for "Kubernetes" and your resume says "k8s", a strict filter misses you. Our guide to [how resume matching algorithms work](/blog/how-resume-matching-algorithms-actually-work/) walks through the keyword, semantic and structured layers in detail.

The second is a human in a hurry. A hiring manager skimming your CV wants to see her own requirements reflected back within the first screen: the stack she listed and the kind of problem she described. A generic resume makes her do the translation; a tailored one does it for her.

Aligning your CV with the job description means describing work you did in the words the employer chose. It is a translation job, and the six steps below keep it honest.

## How to tailor your resume to a job description in six steps

### 1. Keep a master resume

Before you tailor anything, build one document that holds your whole career: each role with six to ten bullets instead of three, side projects, open-source contributions, certifications, talks, and the internal tools that live on your team's wiki and nowhere else. Four or five pages is fine. No employer sees this file.

The master resume is the source you pull from. Without it, you tailor from memory and forget the Terraform migration from two jobs ago, the one that happens to match the posting in front of you. With it, tailoring becomes selection: pick the bullets that fit, rewrite them in the employer's terms, cut the rest.

Keep separate masters if you apply across tracks, such as one for backend roles and one for data engineering. Each master stays complete for its track, and you tailor from whichever fits the posting.

Write master bullets with the specifics attached: the language, the scale and the outcome. You can trim detail when you tailor, and a vague master bullet gives you nothing to trim.

### 2. Dissect the job description

Read the whole posting once, then read it again with a scratch file open. Sort what you find into four buckets.

**Required skills.** The must-haves, often marked "required" or "you have". A posting that says "3+ years of Python in production" means it. If you have it, it goes near the top of your resume. If you lack most of this list, spend your time on another posting.

**Preferred skills.** The "nice to have" list. These separate you from the other candidates who cleared the required bar, so include any you have and leave out the ones you don't.

**Responsibility verbs.** The phrases under "what you'll do": "own the reliability of", "design and operate", "partner with product". These tell you which verbs to use in your bullets and which of your projects to lead with.

**Domain and context terms.** A fintech posting mentions PCI DSS, settlement and reconciliation. A healthcare one mentions HIPAA, HL7 and FHIR. These words signal that you understand where the work happens. Our [resume keywords guide](/blog/resume-keywords-complete-guide-ats-2026/) goes deeper on finding and placing these terms.

Count repeats. A term that appears three times in a posting matters more to the writer than one that appears once, and it belongs in your summary as well as your skills list.

If you use Claude or ChatGPT, paste the posting and ask for these four buckets, with each item quoted verbatim from the text. A prompt along these lines works:

> From the job description below, list the required skills, preferred skills, responsibility phrases, and domain terms. Quote each item verbatim from the posting. Mark any term that appears more than once.

Verbatim matters because a model left to its own devices will paraphrase, and you want the employer's spelling.

### 3. Map your experience to each requirement

Put the four buckets in one column and your master resume in another, and work down the requirements one at a time. For each requirement, find the bullet in your master that proves it and mark the match.

You end up with three groups:

- **Direct matches.** You did the thing with the tool named. Pull the bullet in and move to the next requirement.
- **Adjacent matches.** The posting wants Kafka and you ran RabbitMQ in production. You have the underlying skill (event-driven systems) with a different tool. Pull the bullet in and name your tool; the next step covers the wording.
- **Gaps.** Nothing in the master applies. Leave the requirement alone. A resume that covers seven of ten requirements with evidence beats one that covers ten with two inventions, since an interviewer will probe the inventions in the first technical round.

The mapping also decides order. Within each role, the bullets that match required skills go first. The summary at the top names the two or three requirements you match best. Someone who reads the top third of the page and stops should still see the fit.

### 4. Use the job's own wording, and stay honest

An employer writes "PostgreSQL" and you write "Postgres". A human knows these are the same. A filter might not. Mirror the posting's spelling and form: Kubernetes rather than k8s, CI/CD rather than "pipelines", "on-call" if the posting hyphenates it.

Mirror verbs and framing too. If the posting says "own the reliability of customer-facing APIs" and you did that, write "owned the reliability of the public API" rather than "worked on API stuff with the team". The work is the same; the frame is the employer's.

Three rules keep this honest:

1. Rename what you did and nothing else. Changing "Postgres" to "PostgreSQL" is a spelling fix. Changing "MySQL" to "PostgreSQL" is a lie.
2. For adjacent experience, name your tool and borrow the category. "Event streaming with RabbitMQ" matches a Kafka requirement at the category level while telling the truth about the tool. Add a line saying you are learning the named tool if that is true.
3. Keep each number traceable to something you can explain. A metric you cannot defend in an interview does not belong on the page.

For abbreviations, write both forms once: "continuous integration (CI)". The parser gets both spellings, and the reader gets clarity.

### 5. Format the resume so an ATS can parse it

The best-aligned content fails if the parser cannot read it. Keep the file boring in structure.

- Use standard section headings: Summary, Experience, Skills, Education, Projects. A parser maps these to fields. "My Journey" maps to nothing.
- Avoid tables, text boxes, and images that contain text. Many parsers read these out of order or skip them. If you use two columns, keep the main content first in reading order.
- Use a standard font and real text. A PDF exported from a design tool as a flattened image looks fine on screen and parses as a blank page.
- Date each role in one consistent format, such as "Jan 2022 to Present".
- Submit PDF unless the form asks for .docx. Modern parsers handle text-based PDFs well.
- Put contact details in the body of the document. Some parsers skip headers and footers.

Open your exported PDF and try to select the text. If you can copy your name and a bullet into a text editor and they come out in order, a parser can read it too.

### 6. Run a final check

Put the posting and the tailored resume side by side and walk the requirements once more. For each required skill, point at the line that shows it. For each repeated term, confirm it appears at least once in your words.

Then read the resume top to bottom as the hiring manager would. Does the summary describe this role? Do the first three bullets prove the top three requirements? Did a swap leave a dangling sentence or a mismatched tense?

A keyword overlap count helps here as a sanity check. Paste both texts into a tool that counts which meaningful words from the posting appear in your resume, then scan the misses and ignore the percentage. A miss you can fix with a spelling change (PostgreSQL) is worth fixing. A miss for a tool you have not used stays a miss.

## Worked example: aligning a CV to a backend engineer posting

A condensed excerpt from a representative posting:

> **Senior Backend Engineer, Payments**
>
> - Design, build and operate Go services on Kubernetes that process payments at high throughput
> - Own the reliability of our payment APIs: SLOs, alerting, incident response and an on-call rotation
> - Strong PostgreSQL experience; familiarity with event streaming (Kafka preferred)
> - Work with product and finance to ship compliant payment flows
> - Nice to have: gRPC, Terraform, exposure to PCI DSS

Dissected: the required skills are Go, Kubernetes, PostgreSQL, SLOs and alerting, and on-call. Preferred: Kafka, gRPC, Terraform, PCI DSS. Responsibility verbs: design, build, operate, own the reliability of. Domain terms: payments, compliant, high throughput. "Payment" appears three times.

Now a bullet from a master resume, written for no job in particular:

> Developed backend services for the checkout team in Go, deployed on Kubernetes with PostgreSQL. Ran the team's on-call rotation and set uptime targets and Grafana alerts that cut weekly pages by about half.

The facts the posting wants are in there, under generic verbs. The tailored version:

> Built and operated Go services on Kubernetes for the checkout flow, backed by PostgreSQL. Owned reliability for the payment APIs: defined SLOs and Grafana alerting, ran on-call, and cut weekly pages by about half.

Each fact in the tailored bullet exists in the master bullet: Go, Kubernetes, PostgreSQL, on-call, alerts, halved pages. The changes are verbs lifted from the posting ("built and operated" for developed and deployed, "owned reliability" for running on-call and setting the targets), the phrase "payment APIs" for the checkout endpoints that take payments, and "SLOs" as the employer's name for the uptime targets the engineer set. The tailored bullet adds no new number, no new tool and no new architecture claim.

Kafka stays out, because the engineer has not run it. If the master resume held a RabbitMQ bullet, that bullet would come in as "event streaming with RabbitMQ", which matches the category without claiming the tool.

The skills line changes too. Master: `Go, Python, Postgres, k8s, Docker, Grafana, Terraform`. Tailored: `Go, Kubernetes, PostgreSQL, Terraform, Docker, Grafana, Python`. Same list, employer's spellings, required items first, and Terraform moved up because the posting names it.

## A prompt to edit your resume to fit the job description

If you type "edit the following resume to fit the job description" into ChatGPT or Claude and paste both texts under it, the model will often add a tool you never used or round a number up. A prompt with rules keeps the edit inside your real experience. Copy it, paste the posting and your master resume where marked, and compare the output with your master before you send it.

```text
Edit the following resume to fit the job description below.

Rules:
- Use only facts that appear in my resume. Do not add employers, job titles,
  dates, tools, metrics or degrees.
- Where my experience matches a requirement, rewrite the bullet or summary
  in the job description's wording. Keep my numbers as they are.
- Spell tools the way the job description spells them (PostgreSQL, Kubernetes, CI/CD).
- In each role, put the bullets that match required skills first.
- After the resume, list each required skill from the job description that my
  resume does not show. Do not fill those gaps.

Return the edited resume as plain text, then the list of gaps.

JOB DESCRIPTION:
[paste the posting]

RESUME:
[paste your master resume]
```

The gap list shows the requirements you can't prove. Leave them off the resume, and if the list runs long, spend your time on a different posting. For separate prompts that extract requirements, map your experience and check the output for invented claims, see [ChatGPT prompts for resume tailoring](/blog/tailor-resume-with-chatgpt-claude/).

## Matching your resume to a job description with Resume Matcher (free)

[Resume Matcher](/docs/what-is-resume-matcher/) runs the six steps above with an AI model you already have. I built it after doing this by hand for too many applications. It is free and open source under the Apache 2.0 license, used by over 200,000 job seekers, with 28,000+ GitHub stars. Stanford researchers used it as the resume scorer in [an ICML 2025 paper](https://proceedings.mlr.press/v267/cohen25a.html).

There is no hosted version; you download it and run it on your laptop or in Docker. It doesn't imitate any employer's ATS. Plain code calculates its scores, and step 5 below explains what each one counts.

The workflow:

1. **Add your master resume.** Upload a PDF or Word file (up to 4 MB), or answer questions in the Resume Wizard to build one. Your model turns it into editable sections. You can keep up to five masters, one per career track, and tailoring does not overwrite them.
2. **Connect a model.** In Settings, pick a provider and paste your key: Anthropic (Claude), OpenAI (ChatGPT), Google Gemini, DeepSeek, OpenRouter, Groq, Azure AI Foundry, or Ollama for a free local model. Any OpenAI-compatible server such as llama.cpp, vLLM or LM Studio works too. The app ships no model of its own.
3. **Paste the job description.** Your model extracts required skills, preferred skills, responsibilities and key terms. That is step 2 above, done for you.
4. **Review the proposed edits.** The model suggests targeted changes to your summary, bullets and skills in the posting's wording. Code then checks each change. It locks your name, contact details, employers, titles, dates and degrees, and it reverts any new number that is not in your master. The one deliberate exception is skills: the app may add a skill the posting asks for by name, and it flags those as high-risk in the preview. You see a before-and-after diff and choose Confirm & Save or Reject & Regenerate.
5. **Check the JD Match and ATS Check tabs.** JD Match is plain code with no AI involved. It removes common words from the posting, counts how many of the remaining words appear in your resume, shows the percentage and highlights the matches. Under it, the ATS Score adds up five weighted parts out of 100: keyword match (40%), skills coverage (20%), title match (15%), section completeness (15%) and date consistency (10%). It also lists the job keywords your master resume has and this version dropped, which you can add back without inventing anything. The ATS Check tab renders your PDF and reads the text back the way a plain ATS text extractor does, then reports parseability, reading order and missing sections. Treat all three as the step 6 check: fix spellings and parsing problems, and don't chase the numbers. None of them predicts how a real employer's ATS ranks you.
6. **Export and follow up.** Pick one of seven templates (Single Column, Two Column, Modern, Modern Two Column, LaTeX, Clean, Vivid), set A4 or US Letter, and download a PDF. A headless browser prints the PDF from real text, so a parser can select each word. For the same posting it can also write a cover letter of 100 to 150 words, an outreach message of 70 to 100 words for email or LinkedIn, and interview prep with questions to expect and skill gaps to study. Each tailored resume lands on a Kanban tracker board.

On privacy: the app sends your resume and the posting to the provider you picked, and nowhere else; it contains no analytics code. With Ollama or another local server, the text stays on your machine. The app itself costs nothing. A cloud provider bills you for your own API calls, and a local model costs nothing per request.

Setup is one Docker command:

```bash
docker run --name resume-matcher -p 3000:3000 -v resume-data:/app/backend/data ghcr.io/srbhr/resume-matcher:latest
```

Open `http://localhost:3000/settings`, pick your provider, paste a key, and click Test Connection. To run from source you need Python 3.13+, Node.js 22+ and `uv`. The [getting started guide](/docs/getting-started/) covers both paths, and the [features page](/docs/features/) lists what else is in the box. The repo ships `CLAUDE.md` files and a `docs/agent/` folder, so you can point Claude Code or another coding agent at it and ask it to set the project up.

## Mistakes that make a tailored CV look tailored

**Keywords without evidence.** Adding "machine learning" to a skills list because the posting mentions it, with no bullet to back it, reads as padding to a recruiter and as a trap to an interviewer. List a skill where a bullet proves it.

**Over-tailoring until the story breaks.** If each application rewrites your whole history, the result reads like a collage of postings. Change emphasis, order and wording. Keep the career narrative intact.

**Ignoring tone.** A startup that writes "ship fast and own outcomes" and a bank that writes "ensure control adherence across operations" want different registers. Match the register as well as the terms.

**Skipping the proofread.** Swapping bullets between versions produces duplicate skills and a summary that still names the last company. Read the final PDF once before you upload it.

**Confusing a match score with a verdict.** A keyword overlap tells you which words are missing. It says nothing about whether you will get the interview, and no tool outside the employer's own system can tell you how that system ranks you.

## If this helped

Tailoring takes longer than clicking Apply, and it is the part of the application you control. If the method or the tool saved you time, a star on [Resume Matcher on GitHub](https://github.com/srbhr/Resume-Matcher) helps other job seekers find it, and you can follow me, Saurabh Rai, on [GitHub](https://github.com/srbhr), [X](https://x.com/srbhr_r) or [LinkedIn](https://linkedin.com/in/srbhr).

---
- [All articles](https://resumematcher.fyi/blog)

_[This article was drafted, edited and formatted with the help of AI. Product facts were checked against the Resume Matcher source code, and outside sources are linked where they are used.]_