TailorPilot

A Chrome extension that picks your best-fit resume for any job posting and lightly tailors it — with guardrails. You stay in the loop; it never applies for you.

---

What is this?

Most people applying for jobs keep one resume and send it everywhere. People who apply seriously keep several — one emphasizing product work, one emphasizing data work, one for marketing roles — because the same life reads differently depending on the job. That creates two new problems:

1. Which resume do I send for THIS posting? You end up guessing.
2. Should I tweak the wording for this posting? You should — recruiters and ATS keyword filters both reward it — but doing it honestly, by hand, for every application, takes 20+ minutes each.

TailorPilot solves both, locally, on your machine:

• You browse job postings like a normal person. When you open one, the extension recognizes it (or you paste it in).
• One AI call scores the posting against every resume category you configured, side by side. The highest score picks the resume. You can always override it.
• The winning resume gets a minor tailor: real bullets reordered and re-worded into the posting's vocabulary, rendered as a clean one-page PDF. The cover letter is composed as a proper business letter — date and recipient block, four paragraphs with two proof stories from your resume, ~400 words filling most of one page. Both land in a Desktop folder named after the company and position, so applying to several roles at one company never overwrites anything.
• You review the PDFs, you upload them, you click submit on the real form. TailorPilot never touches the application itself.

Why do we need it?

Autofill tools (Simplify, and others like it) attack the wrong bottleneck. Typing your name and email into forms was never the hard part — the hard part is that you're submitting the same generic resume to a hundred different jobs, and every one of those jobs is scored against candidates whose documents speak the posting's language. Faster submission of a mediocre document is just a faster way to get filtered out.

TailorPilot is the upgrade on the other side of that trade: it doesn't touch the form at all — it makes the document you submit better. And it does it with guardrails that matter when a real recruiter reads the result:

• It never invents anything. Every number, metric, and employer name in a bullet must survive the edit, or the edit is rejected and the original kept. The AI can rephrase your real experience; it cannot embellish it.
• The cover letter can only cite what's on the attached resume. No cross-document inconsistencies, which read as fabrication.
• Hard one-page ceiling, satisfied by tighter phrasing — never by shrinking the font.
• A human clicks submit. Always. There is no code path that sends an application. Not one.
• Sponsorship-language warnings. If a posting says "no visa sponsorship" or "US citizens only," the popup flags it before you spend time applying — but the decision to proceed is yours.

How it works

 Chrome extension                          Local FastAPI (127.0.0.1:8000)
 ┌────────────────────┐  POST /api/ext/register  ┌──────────────────────────┐
 │ detect the posting │ ───────────────────────► │ 1. sponsorship word scan │
 │  · JSON-LD markup  │   (X-TailorPilot-Key)    │ 2. ONE AI call scores    │
 │  · Oracle ORC REST │                          │    the posting vs EVERY  │
 │  · manual paste-in │   poll /tailor-status    │    resume category       │
 └────────┬───────────┘ ◄─────────────────────── │ 3. argmax → best resume  │
          │                                      │ 4. fact-guarded tailor   │
          │                                      │ 5. render one-page PDF   │
     you review,                                 │    (headless Chromium)   │
     you upload,                                 └────────────┬─────────────┘
     you submit                                               ▼
                                      Desktop/TailorPilot Tailored/<Company>/
                                        ├─ Your Name <Company> Resume.pdf
                                        └─ Your Name <Company> Cover Letter.pdf

Everything runs locally. The only thing that leaves your machine is the posting text and your resume content, sent to the Anthropic API for scoring and tailoring. There is no server, no account, no telemetry.

Quick start

Prerequisites: Python 3.11+, Chrome, an Anthropic API key.

git clone https://github.com/SamJ12138/TailorPilot.git
cd TailorPilot

# 1. Install
python -m venv .venv
.venv/Scripts/pip install -e ".[dev]"        # macOS/Linux: .venv/bin/pip
.venv/Scripts/playwright install chromium    # the PDF renderer

# 2. Configure
cp .env.example .env                         # set ANTHROPIC_API_KEY + EXT_SHARED_SECRET
cp config/criteria.example.yaml config/criteria.yaml   # describe your resume categories
cp config/style.example.md config/style.md   # (optional) your writing voice
#    …and drop one .docx resume per category into resumes/

# 3. Run the API (from the repo root)
.venv/Scripts/uvicorn src.api.main:app

Then load the extension: open chrome://extensions, enable Developer mode, click Load unpacked, and select the extension/ folder. Click the TailorPilot icon, open Settings in the popup, and paste the same shared secret you put in .env.

Now open any job posting. If the page is recognized you'll see a JOB badge; clicking the site's own Apply button (or "Record & tailor now" in the popup) records the job and kicks off scoring + tailoring. A minute later the popup shows where your tailored PDFs landed. If a page can't be read, the popup gives you a paste-in card — title, company, and description — which works everywhere.

What it deliberately does NOT do

• No form autofill. You type into applications yourself.
• No auto-submit. Ever. This is a hard design rule, not a missing feature.
• No job scraping or discovery. You find the jobs; it prepares the documents.
• No cloud. Local API, local SQLite database, local PDFs.

Honest limitations

• Scoring and tailoring cost real money (one cheap scoring call + one larger tailoring call per posting — typically a few cents).
• Automatic page recognition covers JSON-LD postings (LinkedIn, Greenhouse, Lever, and most career sites) and Oracle Cloud Recruiting portals. Everything else uses the paste-in card.
• Tailoring quality is bounded by your base resumes. It rearranges and re-words truth; it cannot create it.
• Single-user, localhost-only tool. The shared secret keeps hostile web pages from driving your local API; it is not multi-user auth.
• Developed and tested on Windows; macOS/Linux should work but are less traveled.

Development

.venv/Scripts/pytest -q       # ~115 tests; no API key, DB, or browser required

Layout:

extension/       MV3 Chrome extension (vanilla JS: recognize, record, report status)
src/api/         FastAPI app + the /api/ext/* bridge and background score→tailor chain
src/filter/      one-call multi-category scoring + sponsorship keyword scan
src/tailor/      docx parsing, fact-guarded tailoring, one-page PDF render, export
src/db/          SQLAlchemy models (SQLite by default, Postgres-compatible)
src/config/      criteria.yaml loader (categories, candidate profile, pinned facts)
tests/           in-memory SQLite + fake LLM/renderer fixtures

License

MIT