Automating Job Applications With A Scalable AI System.

Arbeitly is a German job-application service. It worked when the founder handled applications himself — he had a strong personal process for finding the right roles, reading the nuance in a description, deciding what experience to emphasise, and tailoring an application without overstating the candidate.

I was brought in after he hired staff to increase capacity. The team could follow the steps but could not reproduce his judgement consistently, and every application still consumed a lot of manual time.

The engagement covered candidate onboarding, job ingestion from official APIs, an eligibility and matching funnel, grounded CV and cover-letter generation, human review, application tracking and observability.

The real challenge was not writing CVs faster. It was turning the founder’s judgement into a system other people could operate consistently.

Delegating the work made quality inconsistent, and the process still consumed too much staff time. Each application took roughly thirty to forty-five minutes.

• Application quality varied by employee.
• Job selection depended heavily on individual judgement.
• Staff could only review a limited number of jobs.
• CVs and cover letters were tailored by hand, every time.
• More candidates meant proportionally more staff time.
• The founder remained the strongest quality-control layer.
• Scaling increased cost almost linearly.

The problem was not hiring more people. It was turning the owner’s judgement into a process the whole team could execute consistently.

I started by structuring the information the founder used implicitly: work authorisation, language level, location, target roles, seniority, salary expectations, industries, experience and the candidate’s own documents — around fifty fields at onboarding.

From there the system could ingest jobs from Bundesagentur, Adzuna and Jooble, decide which roles were even eligible, score the ones worth considering, generate tailored documents from trusted source material, and hand the final decision back to staff.

• A ~50-field candidate onboarding profile.
• Job ingestion from three official APIs into one normalised pool.
• Hard eligibility evaluated before fit scoring.
• An explainable 0–100 match score with tiers.
• The best base CV and cover letter selected per role.
• AI tailoring from existing evidence only.
• Human review and final submission.
• Application tracking from To Apply through to Offer.

AI recommends and prepares. Humans make the irreversible decision.

The real work started after launch. Candidate data, external APIs, long documents and production failures exposed problems a demo never would.

A pattern emerged quickly: when the system failed, the failure usually looked plausible. A hallucinated metric, a wrong language classification, or a silently missing job could pass unnoticed. Reliability had to come from architecture, not from assuming the model would behave.

We learned to separate bad output from silent bad output. The second is far more dangerous.

Each failure became a design input. The most important change was architectural: stop asking the model to be perfectly careful, and make entire classes of bad behaviour harder or impossible.

• Freeform rewriting → bounded CV patching.
• Prompt warnings → explicit grounding constraints.
• One model for everything → operation-specific routing.
• Silent truncation → visible failure.
• Separate ingestion paths → one normalisation pipeline.
• Nominal fallback → real cross-provider failover.
• Hardcoded prompts → admin-editable configuration.
• Invisible production bugs → Sentry, request IDs, deploy alerts and CI.

The AI could reframe evidence. It could not invent it.

Job discovery, matching, document preparation and tracking became reusable software workflows. Staff spent more of their time reviewing good matches, handling exceptions and completing final submissions.

The founder estimated the manual process at roughly thirty to forty-five minutes per job. The automated workflow reduced application preparation to roughly one to two minutes of handling time, with document generation itself taking about thirty seconds.

Before the system, Arbeitly scaled by adding people. After it, by adding candidates to a repeatable pipeline.

This started as an automation problem and became an architecture problem. The question was not “where can we use AI?” but which decisions are safe to automate, which need structure, and which should stay with a person.

• Hard eligibility should stay deterministic.
• Source-of-truth grounding matters more than eloquent prompts.
• AI should degrade gracefully, not fail autonomously.
• Prompts and weights should be versioned and configurable.
• Observability is part of AI quality, not separate from it.
• Low-confidence outputs should route to stronger models or to humans.
• The feedback loop should close from match → application → interview → offer.

This was never about finding the perfect model. It was about building enough structure around imperfect models that they could reliably do real client work.