Independent AI projects

Independent AI Engineering / Case study

Rolecraft — AI Job Application Tracker

A local-first workspace for organizing opportunities, reviewing evidence-backed job requirements, understanding résumé alignment and tracking applications. A separate interactive synthetic showcase makes the product explorable without deploying the local application.

Interactive showcase live · local-first application complete

Interactive synthetic showcase — no live inference or personal data processing. Real Qwen3 inference is available in the local-first application.

Engineering result

Local-first implementation complete; genuine local inference verified. A separate interactive synthetic showcase is publicly available without live inference or personal data processing.

In this project
Rolecraft local dashboard with fictional synthetic jobs, salaries and application statuses
Synthetic local application capture. All demonstrated jobs, people, résumé content, salaries, notes and scores are fictional. Requirements are human/demo rules; these screenshots do not show a live inference session. Screenshot source ↗

Overview

Built independently for a single user who wants control over job-search data and a reviewable explanation of fit. The local application supports imports, duplicate review, a verified fictional demonstration profile, evidence corrections, application history and approved cover notes. The hosted demo is a separate static showcase: fixed human-authored requirements, invented records and temporary in-memory interactions reset on reload. It runs no AI, accepts no real résumés and stores no applications.

My contribution

I independently designed and built the Next.js/React workspace, SQLite persistence and migrations, local Ollama adapter, evidence validators, deterministic matching, human-review forms, application tracking, cover-note approval, backup/restore, tests and evaluation. I also built the separate static synthetic showcase.

The problem

Job searches scatter opportunities, requirements, résumé evidence, application dates and follow-ups across documents and spreadsheets. A useful assistant must make alignment understandable without inventing qualifications, obscuring missing evidence or sending private résumés to a hosted model.

Architecture

The local React UI sends bounded same-origin commands to a Next.js Node.js API. The store uses Node’s native SQLite driver with prepared statements, WAL, foreign keys and transactions on local disk. An explicit extraction action sends job text only to a server-side loopback Ollama adapter running qwen3:4b. Validated requirements and provenance return to SQLite; pure matching compares them with human-verified résumé evidence. Backup and restore use a separate local workspace route. None of these APIs, SQLite records, backup endpoints or model services is deployed with the portfolio or public showcase.

Simplified workflow · Rolecraft — AI Job Application Tracker
  1. 01Local React workspace → same-origin Node API
  2. 02SQLite · durable records and provenance
  3. 03Explicit extraction → local Ollama / Qwen3 4B
  4. 04Zod + exact source-evidence validation
  5. 05Human correction → explainable fit
  6. 06Tracking · approved templates · local recovery

Local application flow. The public showcase uses bundled fictional records and human-authored requirements, with no live inference, résumé entry or application storage.

Actual local AI inference

Genuine inference passed with Ollama 0.40.16 and qwen3:4b. The explicit local extraction action makes one structured model request; the server verifies model identity, completion, strict Zod output and exact case-sensitive evidence substrings. The request contains job text, not résumé content. There is no paid or remote fallback. This separately recorded local result is not a claim that the hosted showcase runs AI.

Requirement extraction and human corrections

Requirements carry kind, priority, source quote and explicitly supported experience years. Exact quotes, literal terms, duplicates, negation, contradictions and priority evidence are checked before acceptance; invalid candidates are rejected rather than silently rewritten. Human corrections use labeled forms and explicit saving while retaining original inference provenance. Résumé skill extraction uses deterministic local rules, followed by exact evidence review and renewed human confirmation after edits. Lexical validation is conservative, not a general semantic or prompt-injection guarantee.

Transparent matching and application tracking

Required requirements carry weight 3 and preferred requirements weight 1. Evidenced matches earn their weight; missing or unresolved weighted items earn 0. Unknown priority has weight 0, and unassessable constraints remain unknown. Explicit experience compares area and stated years without inferring tenure. Every contribution shows job and résumé evidence. The score measures documented alignment, not hiring probability. Saved, Applied, Interview, Offer and Rejected states, application dates, notes, follow-ups and activity history remain manual; there is no background notification or application submission.

Human-approved deterministic cover notes

Short cover-note templates assemble skills matched to verified résumé quotes. They are deterministic evidence-assembled drafts, not model-generated prose. Users can edit or reject a draft, review its claims and explicitly approve before manual copy. Source changes produce warnings; nothing is sent to an employer.

SQLite durability, backup and restore

SQLite WAL, foreign keys, prepared statements, transactions and versioned migrations preserve local records across restarts. Online backups include profile, jobs, drafts, approvals, history and original/reviewed provenance. Integrity, schema, migration and foreign-key checks precede a preview bound to the exact backup bytes and current workspace state. Explicit single-use confirmation replaces records atomically in one transaction. Corrupt, stale or oversized files fail closed. Backup/restore passed; sensitive plaintext backups are capped at 32 MiB. Cancellation preserves the workspace, and connection-restart tests verify restored values.

Product screenshots

All jobs, résumé content, salaries and scores shown are fictional/synthetic. These committed local-app captures use human/demo requirements, not a live inference session.

Transparent résumé alignment

Rolecraft fit comparison showing a fictional résumé Node.js match, missing PostgreSQL and Redis, and synthetic weighted score contributions
Fictional résumé and job evidence, human/demo requirements and a synthetic alignment score. Alignment is not hiring probability. Screenshot source ↗

Requirement evidence and corrections

Rolecraft requirements review showing human-authored synthetic requirements and exact job source quotes
Human/demo requirement records and fictional job quotes. This capture does not demonstrate live model output. Screenshot source ↗

Local workspace recovery

Rolecraft local backup and restore interface captured in a disposable synthetic workspace
Recovery controls in the local application using invented records. The public showcase has no backup endpoint or private workspace. Screenshot source ↗

Mobile opportunity dashboard

Rolecraft mobile dashboard at 390 pixels showing fictional synthetic job opportunities and statuses
Actual mobile local-app capture with invented opportunities. No real applicant records are shown. Screenshot source ↗

Technical decisions

  • Keep the actual application local-first and single-user. A separate static showcase illustrates synthetic workflows without exposing the tracker server, SQLite, backups or Ollama to the internet.
  • Treat model output as a candidate claim. Validate exact evidence and retain visible provenance, human corrections and explicit profile verification rather than inventing missing qualifications.
  • Use pure deterministic matching and evidence-assembled cover-note templates so people can inspect contributions and approve wording without another model call.
  • Freeze the evaluated inference implementation after a predeclared bounded correction batch. Preserve retained historical controls, the independent holdout and the remaining omission.

Limitations and trade-offs

  • The actual application supports one local server process per workspace and has no multi-user authentication. Internet-facing deployment would require a different access-control and persistence design.
  • CPU inference can take tens of seconds or up to five minutes. Input, output and concurrency are bounded; timeout or invalid output remains visible, preserving earlier validated results.
  • Exact literal validation can reject useful paraphrases and cannot prove semantic completeness. One supported Flask preference remained omitted in the holdout.
  • These small synthetic evaluations do not prove general model accuracy, hiring outcomes or production readiness. Application acceptance can pass while a supported requirement is missing.
  • SQLite and backups are unencrypted plaintext. Protect the device and backups; abrupt parent/OS crashes can leave sensitive temporary files for local cleanup. An uncertain restore response requires reloading to inspect committed state.

Security, performance, and reliability

  • The local API rejects non-loopback Host headers and cross-origin mutations, validates commands and payload limits, and keeps database access and model configuration server-only.
  • Only loopback Ollama destinations are accepted; remote hosts, redirects, credentials and unexpected paths are rejected. Job text is untrusted data; the model has no execution or submission tools.
  • React escapes supplied text, source URLs are not fetched, and CSV export neutralizes spreadsheet formulas. No real résumé, private SQLite records, credentials or machine paths are included in this portfolio.
  • Backup uploads are a local-app feature only. Browser filenames never become server paths; integrity validation, bounded temporary processing and explicit restore confirmation protect replacement.
  • The public demo contains only bundled fictional data and temporary in-memory illustrations. It has no tracker API, résumé entry, uploads, SQLite connection, inference service or persistent application storage. The portfolio adds navigation links and locally served screenshots only.

Testing and verification

  • Genuine local inference PASS: Ollama 0.40.16 with qwen3:4b. This is separate from offline tests, human/demo screenshot requirements and the hosted synthetic showcase.
  • Original quality set: 8/8 application acceptance, combining five actually rerun cases and three historically retained results. This is not eight fresh executions.
  • Independent four-case holdout: 4/4 acceptance, 100% precision (12/12) and 92.3% recall (12/13). One supported Flask preference was omitted and remains counted in recall.
  • Final local product acceptance: 74 unit/integration tests and five Chromium scenarios passed, including actual UI → API → isolated SQLite flows, evidence forms, keyboard/mobile behavior, persistence and backup/restore.
  • Backup/restore and 15 synthetic recovery regressions passed, including corruption/schema rejection, stale previews, cancellation, concurrency, rollback and abrupt-exit recovery. Plaintext backups are limited to 32 MiB.
  • Exact-SHA GitHub CI passed for local release aca0a75 (full commit linked below). CI is offline application verification and makes no live model-accuracy claim. Showcase source: d052577 (full commit pinned in its architecture link).

Results

A complete local-first implementation with separately verified genuine inference, transparent evidence review and tested workspace recovery; a separate public synthetic showcase illustrates the workflow.

  • Local-first implementation complete; genuine local inference verified. A separate interactive synthetic showcase is publicly available without live inference or personal data processing.
  • Evidence-linked requirements, human corrections, reproducible matching, manual tracking and approved deterministic cover-note templates work together with durable local recovery.
  • Measured synthetic acceptance improved while preserving the remaining Flask omission, historical evidence and explicit privacy limitations.

What I learned

  • Exact evidence validation and visible human correction are useful boundaries, but they do not make probabilistic extraction complete.
  • A successful application response can still miss a supported preference. Report precision, recall, retained controls and omitted evidence alongside acceptance.
  • Privacy depends on deployment boundaries as well as implementation. A static synthetic showcase can explain a local product without publishing its private data or server capabilities.
  • Recovery deserves product-level testing: preserve approvals and provenance, bind confirmation to the reviewed file and workspace, and test failure before replacement.

Technology and links

Next.js · React · TypeScript · Node.js · SQLite · Ollama · Qwen3 4B · Zod · Vitest · Playwright

Related work

Have a similar engineering challenge?

Let’s discuss the product, the constraints, and where I can contribute.

Get in touch