KeinplanKarriere — an AI agent that makes job applications easier

The problem

Applying for jobs is a second job

Anyone who has job-hunted in Germany knows the drill. Three things make it exhausting — and all three are automatable without taking a human out of the loop.

Fragmented

The same role is posted on LinkedIn, StepStone, Xing and the Arbeitsagentur — so you search four sites and read the same job four times.

Repetitive

Every serious application means rewriting your CV and cover letter for that specific posting. 30–60 minutes, each time.

No feedback

You never find out which skills the market actually wants, or which kind of application got you a reply.

The usual outcomes are both bad: fire off generic applications everywhere, or burn out perfecting three.

What it does

One agent, the whole loop

Four stages. Each one is useful on its own, and each feeds the next.

Find

Search once from the dashboard; it queries four boards in parallel, pulls the full description of every posting, tags the skills, and merges duplicates across boards into one entry.

Match

Every job gets a 0–100 score against your experience and preferences, with the breakdown shown. The strongest candidates get a second, AI-written verdict that explains itself.

Apply

One click builds a CV rewritten for that job — keeping all your experience, rephrased to the posting — plus a matching cover letter, both as compiled PDFs, with the apply link and a checklist.

Improve

Mark a job as interview or offer and the agent learns: jobs sharing those skills rise in the ranking, and the AI scorer is told what has been working for you.

Grounded in you, not invented. You upload your CV once; the AI parses it into a reviewed experience base — and you confirm every entry before it is saved. Every score and every generated document is built from that. The agent never invents an employer, a date or a technology you don't have.

Product walkthrough

See it work, step by step

Real screens from the running app. It advances on its own — or click a step to jump.

1 / 5

keinplankarriere

A deliberate design choice

An assistant, not an auto-apply bot

This was the hardest product decision in the project, and the answer shaped the whole apply flow.

Why not automate submission?

Auto-submitting to job boards violates their terms of service, requires storing your login credentials, and breaks the moment a form or bot-check changes.

It also fails you

An application sent without a human read is exactly the low-effort spam that recruiters filter out. Volume is not the bottleneck — quality per application is.

What we built instead

The Apply Assistant: tailored CV, cover letter, the posting link and a pre-submit checklist, prepared in one click. You review and send in seconds — with full control over what goes out.

Same time saved. None of the risk — and nothing leaves your hands without you seeing it.

Under the hood

How the matching engine works

Deliberately hybrid: cheap deterministic logic does the bulk of the work, and the language model is reserved for genuine judgment.

Layer 1 — rule-based score (every job)

Instant, free and reproducible. Weighted components, always visible in the UI:

Skills

Role

Location

Remote

Seniority

Salary

Skills measures the share of the job's requirements you cover — so adding experience can only ever raise a score, never lower it.

Layer 2 — AI refinement (top candidates only)

The best rule-scored jobs go to the language model, which reads the posting and your actual experiences, re-scores 0–100, and writes a one-line justification you can argue with.

Cost control: each score is fingerprinted from its inputs. Re-running a scoring pass reuses cached verdicts for unchanged jobs — a repeat run costs zero API calls.

Resilience: if the model provider retires or fails a model mid-request, selection re-resolves against the live catalogue and retries; if the AI is unavailable, the rule score still stands.

Skill extraction

A curated taxonomy of ~70 technologies with their aliases (React / ReactJS / React.js → one skill), matched with word-boundary regexes so “Java” never matches inside “JavaScript”. German and English.

Cross-board deduplication

Titles and companies are normalised (gender markers like (m/w/d), legal suffixes, punctuation stripped) then compared with difflib similarity. Above threshold, entries merge and record “also on”.

Document generation

Your LaTeX résumé is rewritten per job, then compiled to PDF with Tectonic. If a tailored version fails to compile, it retries, then falls back to your known-good template — you always get a valid PDF.

Architecture

How the system is put together

One Docker image: a FastAPI backend that also serves the built React dashboard, an embedded SQLite database, and a LaTeX engine for documents.

Browser

React dashboard

Jobs · Experience · Trends · Settings — served as static files by the API

↓ cookie session per visitor

FastAPI application

REST API

jobs, applications, experiences, matching, generation, settings

Session layer

an isolated workspace per browser; idle ones expire automatically

Work queue

one serial worker for all heavy jobs, with live “position in line”

↓

Workers & storage

Scrapers

requests + BeautifulSoup per board; official REST API for Arbeitsagentur

SQLite

jobs, experiences, profiles, settings — all rows scoped to a session

Tectonic

LaTeX → PDF for CVs and cover letters

LLM provider

any OpenAI-compatible API — the visitor's own key

A workspace per visitor

Every browser gets its own jobs, experiences, documents and settings, keyed by a cookie. Nothing is shared between visitors, and idle workspaces are purged with their generated files.

Fair-use queue

Scraping, scoring, parsing and document generation all run through a single worker. Several people can use it at once on modest hardware without the machine falling over.

Bring your own AI key

Visitors paste their own LLM key (Groq, OpenRouter, Kisski, …), so no credentials are shared and the host pays nothing. Search, dedup and rule-based ranking work with no key at all.

The product

Every screen, real data

Job detail view with score breakdown — **Score breakdown** — component-by-component, plus the AI's written verdict and which skills you match or miss.

Apply Assistant with generated CV and cover letter — **Apply Assistant** — tailored CV and cover letter as PDFs, the posting link, and a pre-submit checklist.

Experience base built from a parsed CV — **Experience base** — parsed from your CV (you review before saving) or added by hand; the AI infers type and stack.

Market trends analytics — **Market trends** — the skills actually in demand across your tracked jobs, salary ranges, remote split and top locations.

Try it yourself

Run the whole thing in one command

Everything ships in a single Docker image — API, dashboard and the LaTeX engine. No local Python, Node or TeX install needed.

It runs on your machine by design: the agent scrapes job boards from your address, keeps your CV and documents on your disk, and uses your own AI key. That is deliberately not something to centralise on someone else's server.

# 1 · clone
git clone https://github.com/Aminebenbelaid/KPK-agent.git
cd KPK-agent

# 2 · configure (copy the template, set your keys)
cp .env.example .env

# 3 · run
docker compose up -d --build

# 4 · open
http://localhost:8000

First run downloads the LaTeX packages it needs and caches them, so the first CV takes a little longer than the rest.

Then, in the app

Settings → paste an LLM API key. Groq is free and works out of the box; OpenRouter, Kisski or any OpenAI-compatible endpoint also work.
Experience → upload your CV (PDF or LaTeX) and confirm what the AI extracted, or add entries manually.
Jobs → run a search, then Score all jobs.
Open the best match → Prepare application → download your tailored CV and cover letter.

Without an AI key, search, deduplication and rule-based ranking still work — only the generative features need one.

How it was built

Four sprints, shipped end to end

Each sprint ended with something that ran, not a prototype in a branch.

Sprint 1

Collect & track

Four working scrapers, a FastAPI + SQLite backend and the React dashboard. Jobs could be searched, stored and tracked through application statuses. Deployed in Docker from day one.

Sprint 2

Matching & profile

Skill extraction, fuzzy cross-board deduplication, the weighted rule score plus AI refinement, and the experience base parsed from a CV — the point where rankings became personal.

Sprint 3

Generation & apply

Full job descriptions from every board, tailored CV generation, cover letters, the Apply Assistant, market trends, and outcome-based re-ranking with response caching.

Sprint 4

Multi-user & public

Per-visitor sessions, the serial work queue, bring-your-own-LLM-key, CV photo upload, and a public deployment — turning a personal tool into something a stranger can safely use.

Python 3.12FastAPISQLite React 18 + ViteBeautifulSoupTectonic (LaTeX) Docker ComposeOpenAI-compatible LLM

LinkedInStepStoneXingArbeitsagentur