Every recruiter I know has the same quiet anxiety about inbound: the good applications get buried under the volume, and the tools that promise to fix it want to hoover up every CV into a model you can't see. I wanted the opposite — a system that reads applications the way I would, ranks them against the actual brief, and keeps every byte of candidate data on hardware I own.
This is the build. It runs on a Mac mini under my desk, costs nothing per query, and has scored roughly four thousand applications without a single row leaving the machine. Here's how it fits together, what worked, and the parts I'd still change.
```
**§1 — `
The shape of the problem
`**
```html
Scoring a CV is not a ranking problem, it's a reading problem. A keyword filter throws out the career-changer with exactly the right transferable experience and keeps the person who pasted the job description into their summary. So the first decision was to give a local model the same rubric I'd hand a junior researcher, and ask it to explain itself.
The moment you can read the model's reasoning next to its score, you stop trusting the score and start trusting the process. That's the whole game.
— from my own notes, week two
The pipeline has three stages: ingest (parse the CV to clean text), score (run it through the model against a rubric), and store (write score, reasoning, and flags to Postgres). Nothing exotic.
```
**§2 — `
Wiring up the model
`**
```html
I use Ollama to serve the model locally. The scoring call is a single prompt with the rubric baked in and the CV text appended. The key trick is forcing structured output so the result drops straight into a database column.
```
…then the **code block** (see §2a below), then:
```html
Temperature stays low so scores are stable run-to-run. The format="json" flag matters more than the prompt — without it you spend your evening writing regex to fish a number out of a paragraph.
```
…then the **figure** (see §2b below).
**§3 — `
What the numbers looked like
`**
```html
After a month I compared the model's top-decile picks against the candidates I'd actually progressed. The overlap was better than I expected, and where it disagreed it was often right — surfacing people I'd have skimmed past.
```
…then the **table** (see §2c), then:
```html
The 8B model won on the desk because latency compounds: at two seconds a CV, a morning's inbound clears while I make coffee. The gap to 70B wasn't worth a fourteen-fold slowdown for my volume.
```
…then the **inline newsletter CTA** (see §2d).
**§4 — `
The parts I'd still change
`**
```html
Two things. First, the rubric lives in a Python dict, which means editing code to tweak a brief — that belongs in a small table so I can change it from a UI. Second, I score CVs in isolation; the interesting signal is relative, and a re-ranking pass across the whole batch would sharpen the top ten considerably.
Move the rubric into Postgres so briefs are data, not code.
Add a batch re-rank pass for relative scoring.
Log the model's reasoning verbatim — it's the audit trail that makes this defensible.
None of this is hard. That's rather the point: the tools to keep candidate data private and score it well are sitting on your machine already. You just have to wire them up.
```
**Tags (end of article):** `#deep-dives` `#local-llm` `#self-hosted` `#sourcing`
### §2a — Code block (language: `python`, file: `score.py`)
Syntax colours are **hand-authored spans** — `.tok-com` comment, `.tok-key` keyword, `.tok-fn`
function, `.tok-str` string, `.tok-num` number. Recolour these tokens to suit your palette; keep
the class names and the code exactly as-is.
**⚠ The `
` must keep `white-space: pre`.** A previous mockup (`post-8.html`) lost it when a
line-number gutter was added and the code collapsed onto one line. Do not repeat that.
```html
python
# score.py — rank one application against the live briefimport ollama, json
defscore_candidate(cv_text, rubric):
prompt = f"""You are screening for: {rubric['role']}.
Score 0-100 on fit. Return JSON with keys:
score, reasoning, flags."""
resp = ollama.chat(
model="llama3.1:8b",
messages=[
{"role": "system", "content": prompt},
{"role": "user", "content": cv_text},
],
format="json", # hard-constrain to JSON
options={"temperature": 0.2},
)
return json.loads(resp["message"]["content"])
```
**Copy button** — required, and it must actually work. Shared script (place before `