Build Huntr

YESreplaces $40/mosaves $480/yrback to the verdict

0%0 of 20 items done

Saved on this device only. Tick prerequisites first, then work the phases in order · do not start one until the checks above it pass.

A local workspace tracking applications through stages, storing the job description alongside each one, holding a master record of your real experience, and generating tailored documents where every bullet is linked to an entry in that record so nothing is invented.

estimated effort weekendthe files for this build are in the project pack

RuntimeTypeScript with Vite, running locallyStorageSQLite, with documents as files on diskDocumentsMarkdown as the master format, rendered to PDFTailoringRetrieval over your evidence record, with a model constrained to itRenderingA typesetting step producing consistent PDFs

Before step 1

Everything below is assumed from the first step. Tick each one when you actually have it, not when you plan to.

installfree
Why Runs the build and the rendering pipeline.
Get it nodejs.org, or nvm install 22. open ↗
Verify node --version prints v22 or higher
have readyfree, and it is the most valuable hour in this build
Why Phase 3 is the foundation of everything after it, and it cannot be generated. Roles, dates, projects and any metrics you could actually defend.
Get it Set aside an hour and write it from memory and from records, not from an existing resume. Where you want to claim a number, find the number.
Verify Every role and project you would mention has an entry with real dates
API keypay per token; tailoring one document is a fraction of a cent
Why Phase 4 only. Tracking, capture and the evidence record all work with no model at all.
Get it A provider key with a spend limit set, or Ollama with a local model if you would rather your job search stayed on the machine.
Verify A tailoring run completes and its provenance is recorded
installfree
Why Employers want PDFs and applicant tracking systems parse them, so the output has to be real text rather than an image.
Get it A headless browser print path or a typesetting tool. Whichever you choose, confirm the output text is selectable.
Verify Generated PDF text can be selected and copied
have readyfree
Why Tailoring and retrieval cannot be judged against invented postings, and real ones contain the vague requirements that break naive keyword matching.
Get it Save five postings for roles you would actually apply for.
Verify Five descriptions are stored as fixtures

Data model

Create these before the first phase that stores anything. Changing a table later is the expensive kind of change.

- applications(id, company, role, url, source, applied_at, stage, salary_range, location, notes)
- stages(application_id, stage, entered_at) · the history, so you can see how long each stage actually takes
- descriptions(application_id, text, captured_at) · the job description as it was when you applied, because postings disappear
- evidence(id, kind, title, organisation, started_at, ended_at, text, metrics_json) · your master record of what you actually did
- documents(id, application_id, kind, path, generated_at, evidence_ids_json) · which evidence entries produced this document
- contacts(id, application_id, name, role, notes), tasks(id, application_id, due_at, text, done_at)
- The evidence identifiers on a document are the audit trail: every claim traces to something you recorded about yourself.

Environment variables

These go in a .env file the app reads at startup. The pack's .env.example is this table as a file · copy it, never commit the filled-in version.

Variable	Needed	Example	Where the value comes from
`DB_PATH`	required	`./data/search.db`	Applications, evidence and documents. Private, and worth backing up.
`DOCUMENTS_DIR`	required	`./data/documents`	Generated Markdown and PDFs.
`MODEL_PROVIDER`	required	`local`	Which adapter tailoring uses. Local means your job search stays on the machine.
`MODEL_API_KEY`secret	optional	`sk-...`	Only for a hosted provider. Set a spend limit at the provider too.
`MIN_FONT_PT`	required	`9.5`	Below this the renderer reports overflow rather than shrinking further.
`STALE_DAYS`	required	`14`	How long without movement before an application is surfaced for follow-up.

The build, in order

1
Applications and their stages
You can see every application and how long it has been sitting.
1. One row per transition. The current stage is derived from the latest row.
  Files src/applications.ts
2. Board for a sense of the pipeline, list sorted by staleness for deciding what to do today.
  Files src/views/
3. Average days per stage, and which applications have gone quiet. This is the number that changes behaviour.
  Files src/stats.ts
done when · tick each as it passes
watch out
- Storing only the current stage loses the timing, which is the information that actually helps: knowing that applications sit in one stage for three weeks changes when you follow up. Store transitions as rows, not a single field.
next phase
2
Capturing the posting before it disappears
You still have the job description when they call you three weeks later.
1. Paste is the reliable path. A link is stored too, but as a convenience rather than the record.
  Files src/descriptions.ts
2. Check the site's terms before automating a fetch. Many job boards forbid it, and paste always works.
  Files src/capture.ts
3. Re-checking marks a posting gone and keeps the captured text. The text is the point.
  Files src/capture.ts
done when · tick each as it passes
watch out
- Job postings are taken down constantly, often before an interview, and preparing without the description you applied against is a real disadvantage. Capture the text at application time rather than storing a link, because the link will break exactly when you need it.
next phase
3
An evidence record of what you actually did
Every claim you might make exists in one place, in your own words, before any tailoring.
1. Not from an existing resume. Your own words, with dates and real numbers only where you can support them.
  Files src/evidence.ts
2. A metric is a number you could defend in an interview. If you cannot, leave it empty; an empty field is better than one you have to walk back.
  Files src/evidence.ts
3. Full text over entries, since tailoring starts with finding relevant ones.
  Files src/search.ts
done when · tick each as it passes
watch out
- Skipping the evidence record and tailoring directly from a previous resume means the model is rephrasing a rephrasing, and small exaggerations compound across applications until you cannot remember what you actually claimed. Write the record once from what you did, and treat every document as derived from it.
next phase
4
Tailoring that cannot invent
A tailored document is a rearrangement of things you did, and you can prove it.
1. Search the evidence record against the description, and pass only the retrieved entries. The model never sees your whole history at once.
  Files src/tailor.ts
2. A checking step mapping each generated bullet to an entry. Unit test it with a crafted unsupported claim rather than waiting for a model to produce one.
  Files src/validate.tssrc/validate.test.ts
3. Evidence identifiers on the document row, shown in the interface next to each section.
  Files src/documents.ts
done when · tick each as it passes
watch out
- A model asked to tailor a resume will add a plausible achievement you never had, and it will be the most impressive line on the page. Validate every claim against the evidence record and reject the generation rather than trusting an instruction, because the failure mode here is discovered in an interview.
next phase
5
Documents that look right every time
A generated PDF is consistent, readable and fits the page.
1. One template, deterministic output. Compare two renders of the same content byte for byte.
  Files src/render.ts
2. A minimum type size below which the render reports a problem instead of continuing.
  Files src/render.ts
3. The Markdown next to the PDF. Regeneration and editing both need it.
  Files src/documents.ts
done when · tick each as it passes
watch out
- Auto-shrinking type to fit a page produces a resume nobody can read at seven point type, and the tool that did it never says so. Report the overflow and let the writer cut something, because the decision about what to remove is theirs.
6
Follow-ups, privacy and exportproduct builder
Nothing falls through, and your job search is not sitting somewhere you cannot delete it.
1. Due dates per application, plus a prompt for applications that have not moved. Following up is most of the value of tracking.
  Files src/tasks.ts
2. JSON for completeness, Markdown for reading. A job search you cannot take with you is a lock-in you did not need.
  Files src/export.ts
3. One deletion covering every table, verified by search. And a plain statement of what reaches a provider.
  Files src/delete.tsREADME.md
done when · tick each as it passes
watch out
- A job search is unusually sensitive: it reveals that you are leaving, and where you applied. If tailoring uses a hosted model, your evidence record and the job descriptions leave your machine. Say so plainly and offer a local model path, because this is a case where the privacy preference is often strong.

what this build does not replace

Browser capture from job boards.
Recruiter contact enrichment.
Job board distribution and one-click applying.
Any claim to improve your chances.
browser capture, AI writing, resume builder, contact enrichment, and sync
proprietary recruiter data
job-board distribution
human coaching
automated application networks

after v1, if you want it

Interview notes attached to an application, which are worth more than the tracking
A comparison of stage timing across sources, so you learn which channels actually progress
Cover letter generation from the same evidence record and the same validation

Need the files? The project pack on the verdict page hands your agent the whole brief · more career.