JobPilot — Finds jobs, tailors applications and fills forms, but never submits without a final yes

Overview

The project at a glance.

391automated tests, including a 110-test end-to-end suite

106local API endpoints behind the desktop console

8job sources searched through approved routes only

7built-in site adapters, from Workday to NHS Jobs

JobPilot is a desktop assistant for people applying for jobs. It finds vacancies across job boards, checks each one against the candidate's own experience, drafts a tailored CV, cover letter and answers, and fills in the employer's application form. The candidate's details are stored encrypted on their own PC, every drafted sentence is checked against their real record, and no application is submitted until they have reviewed it and confirmed it themselves.

Who it serves
Job seekers applying at volumeOne profile that fills Workday, Greenhouse, Lever and other application forms, with a tailored CV and cover letter drafted for each role.
Public-sector applicantsCriterion-by-criterion supporting statements for NHS and Civil Service style applications, written to word limits from their own career stories.
Privacy-conscious candidatesNo JobPilot account and no cloud service: the profile, documents and job-site logins stay encrypted on their own computer, and backups are encrypted wherever they are saved.

The challenge

Applying for jobs is mostly re-typing the same facts

Every employer's applicant tracking system asks for the same facts in different wording, layouts and page sequences. The project's design-stage estimate is that a careful application takes 30 to 90 minutes, most of it spent copying dates, employers and grades, matching awkward dropdowns and retelling the same handful of career stories.

Tools that simply let an AI drive the browser look impressive in demos but are hard to trust: they can overstate experience, click the wrong button or send an application nobody has checked. Candidates also need their CV, right-to-work answers and passwords kept private, and some large job sites forbid automated applications altogether.

What we built

An assistant that does the typing and leaves the judgement to the candidate

VNE designed and built JobPilot as a local-first desktop app for Windows. It searches approved job sources, reads each advert, scores it against the candidate's profile requirement by requirement, and prepares a tailored CV, cover letter and answers in which every sentence is traced back to the candidate's own records.

Once the candidate has approved those drafts, JobPilot follows the employer's apply journey in a dedicated Chrome profile, fills the form page by page, reads every value back and stops at a final check. It presses the site's submit button only after the candidate confirms that one application. CAPTCHAs, verification codes, declarations and consents are always left to the person.

The profile, documents, applications and job-site logins are kept in an encrypted vault on the user's PC. AI is optional: without it JobPilot works from deterministic rules and fixed phrasing, and when Claude is switched on it only sees work-related facts, never contact details, right-to-work status, salary or equality answers.

Key features

What it does.

Find jobs through approved routes

Saved searches run across Reed, Adzuna, Jooble, jobs.ac.uk, employers' public job boards, RSS feeds, Google Jobs (via SerpApi) and job-alert emails. A vacancy found on several sites becomes one entry that lists every source.

Fit analysis with the evidence shown

Each requirement in an advert is marked Met, Partial or Gap, with the profile evidence behind it. The fit score is calculated in code, never taken from an AI.

CVs, letters and answers backed by evidence

Every drafted sentence cites the role, STAR story or certification it rests on. A checker in code removes any sentence whose numbers, certifications or names cannot be found in those sources.

Form filling with read-back

Fields are matched to the profile by a deterministic cascade and filled across multi-page forms, including dropdowns, typeaheads, repeated job-history sections and file uploads. Every value is read back from the page to confirm it landed.

Final check and confirmed submit

JobPilot stops on the last page and shows exactly what it entered and which button it will press. It submits only when the candidate confirms that application, once.

Encrypted local vault

The profile, documents, drafts and job-site logins are encrypted on the PC and opened with a passphrase or recovery code. Every change is kept as a new version, and each backup is checked by decrypting it before it is trusted.

Tracker, follow-ups and insights

Every application has a timeline and an outcome, with a reminder to follow up when an employer goes quiet, CSV export, read-only Gmail or Outlook linking of employer replies and a simple funnel of what is working.

Chrome extension and Claude app link

A Chrome extension sends adverts to JobPilot and offers copy-assist on sites that forbid automation. An MCP server lets the Claude desktop app check progress and queue jobs, but it can never approve drafts or submit.

Audit trail and self-diagnosis

Every run keeps a tamper-evident audit log, screenshots and a field-by-field record. A setup check and redacted problem reports help diagnose issues without exposing personal data.

Inside the product

See it in action.

Screens captured from the working application using fictional demo data.

Find jobs screen with two saved searches and a ranked list of fictional vacancies tagged with the job sources they came from — Saved searches run across the job sources the user has set up. Each card shows what every source found, and the list is ranked by match score with each vacancy's sources shown as tags.

Vacancy detail for a fictional ERP Programme Manager role merged from Adzuna, Jooble and Reed, with a quick fit check and the advert text — One vacancy advertised on three sites becomes a single entry. JobPilot shows where it is advertised, the most direct place to apply and a quick fit check against the profile.

Requirement by requirement, each line is Met, Partial or Gap and names the stories, skills, roles or certifications behind it. Budget ownership of £10m is only Partial, with a prompt to add a story that shows it.

A cover letter assembled without AI from the candidate's own stories. Every sentence is linked to the role, STAR story or certification it rests on, and nothing is used until it is approved.

Drafted answer to a competency question found on an application form, with sentence sources and an option to save it for reuse — The form asked a question JobPilot had no answer for, so it drafted one from two STAR stories and paused. Approving it can also add it to the reusable answer library for future forms.

Queue screen with a filled application held for the final check, a declaration left unticked and a Submit this application button — The final check. The form is filled and held open, the declaration is left for the candidate, and the button JobPilot will press is named. Nothing is sent until the candidate confirms.

CV import review listing the name, contact details and roles read from a fictional Word CV — CV import with no AI configured: contact details, roles, dates and achievements are read from a Word CV into a draft. The candidate unticks or corrects anything wrong before it reaches the profile.

The encrypted, versioned profile. Right-to-work and equality answers are marked sensitive and never sent to AI, and the STAR stories are the evidence that drafted answers and letters cite.

Chrome extension copy-assist panel beside an empty application form, listing suggested answers with Copy buttons — The Chrome extension's copy-assist panel, shown here on the built-in test form. It suggests answers with a Copy button but never types or clicks, and leaves right-to-work and equality questions to the person.

Run record table listing each form field, the value entered, confidence, outcome and the reason for the mapping — The record behind every form fill: each field with the value entered, its confidence, the read-back result and why it was mapped, including a phone number reformatted after the site rejected it.

Test runs screen with practice-site scenarios, previous runs and their outcomes, and a site adapter health table — Operations view: the built-in practice site's scenarios (CAPTCHA, sign-in wall, validation error, unknown question, missing data), previous runs and their outcomes, and adapter health showing how often each site reached the final page, not counting CAPTCHAs and sign-ins that always need a person.

Job source settings for Adzuna, Jooble and Reed with saved keys hidden and test buttons — Job-source settings. Official APIs use the user's own keys, which are stored encrypted and never shown again. Sites without an API are reached through alert emails rather than scraping.

Workflow

How an application gets from advert to submission

01
Build the profile
Import a CV in PDF or Word, check what JobPilot found, then add career stories and approved answers. Every save is a new encrypted version.
02
Find and assess jobs
Searches run across the chosen sources. Each vacancy is filtered against the candidate's criteria, merged with duplicates and scored against the profile.
03
Prepare and approve
JobPilot drafts a tailored CV and cover letter. The candidate edits and approves each item, and nothing unapproved is ever used.
04
Fill the application
The engine follows the apply journey to the real form, fills it with approved content and pauses for anything only a person should do.
05
Final check and track
The candidate reviews every value, answers the declarations and confirms. JobPilot submits, waits for the confirmation page and tracks the outcome.

Under the hood

How it's built.

JobPilot runs on the user's own Windows PC. A small Python service holds the encrypted data and the logic, a local web console shown in its own window is the interface, and an automation engine drives a dedicated Chrome profile to fill in forms. Apart from the adverts it reads and the employer sites it fills in, its only outside connections are to the job sources the user switches on, their own mailbox (read-only) and, optionally, the Claude API with minimal, work-related context.

Technically, it is a modular monolith. FastAPI listens only on the loopback address, checks the Host header and requires a custom header on every write. Background workers read adverts, run searches, work through the application queue, sync email and make backups. Playwright controls the browser, and SQLite stores every record separately encrypted with AES-256-GCM. Site knowledge lives in declarative adapters, job sources are self-contained plug-ins, and a local ATS simulator lets the whole pipeline be tested end to end without touching real employers.

01Clients

Desktop consoleSingle-page HTML and JavaScript in a pywebview (Edge WebView2) window
Chrome extensionManifest V3: send a job, copy-assist; never fills
Claude desktop appMCP server over stdio: read and queue only

02Local API and workers

FastAPI console106 endpoints, loopback-only, with a write-header check
Background workersAdvert reading, daily searches, application queue, email sync, backups

03Engines

Search and de-duplication8 source plug-ins, filters and cross-source merge
Analysis and contentRules-first fit scoring; cited drafting and claim checker
Form engineSnapshot, mapping cascade, executor, apply journey, submit guard

04Data

Encrypted vaultSQLite; Argon2id-wrapped keys, AES-256-GCM per record
Audit and run recordsHash-chained JSONL logs, screenshots, form snapshots
BackupsEncrypted snapshots, checked by decrypting every record

05External services

Job sourcesReed, Adzuna, Jooble, jobs.ac.uk, public ATS boards, feeds, SerpApi
Employer application sitesReached through a dedicated Chrome profile
Gmail and OutlookRead-only OAuth 2.0 with PKCE
Claude API (optional)Anthropic SDK; redacted, work-related data only

Technology

Frontend

Vanilla JavaScript SPA
HTML and CSS
pywebview (Edge WebView2)
Light and dark themes

Backend

Python 3.11+
FastAPI 0.115+
Uvicorn
Pydantic 2
Playwright for Python 1.55+
RapidFuzz
python-docx
pypdf
Chromium PDF output

Data

SQLite
Record-level encryption
Versioned vault records
Encrypted search cache

AI & ML

Anthropic SDK (optional)
Model set in configuration
Sentence-level citations
Deterministic claim checker
Second-pass AI verification

Integrations & APIs

Reed Jobseeker API
Adzuna API
Jooble API
SerpApi Google Jobs
Greenhouse and Lever boards
Ashby and Workable boards
SmartRecruiters and Recruitee boards
RSS and Atom feeds
Gmail API (read-only)
Microsoft Graph (read-only)
MCP over stdio

Auth & Security

Argon2id key derivation
AES-256-GCM
HKDF subkeys
OAuth 2.0 with PKCE
Hash-chained audit log
Loopback-only API
DNS-rebinding defence
Cross-site request defence

Hosting & DevOps

Runs locally on Windows
uv with a lockfile
GitHub Actions CI
Ubuntu and Windows runners
Inno Setup installer
Chrome Manifest V3

Testing & Quality

pytest (391 tests)
Headless Chromium end-to-end tests
Local ATS simulator
CAPTCHA and sign-in scenarios
FastAPI TestClient
Fake API transports

Engineering highlights

The hard parts, solved.

01
Making 'never submit without me' a guarantee
Every click the engine makes goes through a submit guard in code. Anything that looks like a final submit, or can't be classified, is refused unless the candidate has confirmed that application in the console. The authorisation names the exact button and the page's structural fingerprint, carries a one-time code from the final-check screen and is used up by a single click, and neither the MCP server nor the extension can grant it.
02
Stopping AI from inventing experience
Drafts are built sentence by sentence with citations to the profile. A deterministic checker requires every number, certification and proper name in a sentence to appear in the sources it cites, and failing sentences are removed rather than reworded. Confidence is calculated, not self-reported: only a verbatim approved answer is rated high. Certifications are matched exactly, so a Foundation certificate never satisfies a Practitioner requirement.
03
Reading forms that were never designed for automation
A snapshot script walks each page, including open shadow roots and iframes, to capture labels, options, required flags and errors. Each field is then mapped through a seven-step cascade: site adapter, mappings the user has confirmed on that site, autocomplete attributes, synonyms from a 45-field ontology, name or id, approved answers and fuzzy matching. Values are read back after filling, site validation errors trigger reformatting, and anything uncertain goes to the person.
04
Keeping personal data local and minimal
The vault derives separate keys for records, sensitive answers and files, and binds every ciphertext to its record type, id and version so records can't be swapped or replayed. It locks itself after 15 minutes idle, and background tasks never keep it unlocked. Contact details are parsed on the PC and redacted before any AI call, job-site passwords are only ever typed into sign-in and sign-up pages, and problem reports replace entered values with their length.
05
One apply journey across many different sites
Applications rarely start on the form. A page classifier recognises adverts, cookie banners, account choices, sign-in and sign-up pages, verification steps, closed jobs and one-click 'quick apply' buttons, and does the one safe thing at each: turning down optional cookies, applying as a guest where offered, signing in with the saved login, or stopping to wait for the person.

Outcome

A working MVP, ready for trials on real job sites

The repository records phases 0 to 9 of the build plan as built, with unattended submission deliberately left out by the owner's decision. The code carries 391 automated tests, and GitHub Actions workflows are set up to run them on Windows and Ubuntu and to build the Windows installer. For this case study the application was run locally with a fictional candidate, fictional vacancies and the built-in ATS simulator: one application went through to a confirmed submission on the simulator and another stopped at the final check.

JobPilot shows how VNE approaches AI in sensitive workflows: code decides what is allowed, AI is optional and checked, the candidate's data is stored encrypted on their own device, and every action leaves an audit trail.