JobFoundryAGPL-3.0
GitHub
Docs/Architecture & Internals

JobFoundry Pipeline Architecture

JobFoundry is structured as a decoupled, multi-stage processing pipeline that converts unstructured web job listings into deduplicated, score-ranked opportunities with tailored ATS resumes.

The Architectural Invariant

The JobFoundry server never performs outbound job-board scraping. All scraping and job-board HTTP requests originate from the user's browser extension.

By delegating ingestion to the client extension, JobFoundry bypasses aggressive IP rate-limiting, Cloudflare bot challenges, and CAPTCHAs, while ensuring user credentials and session tokens never leave the browser.

Interactive Pipeline Visualizer

Click through each stage to view the architectural rationale and code implementation:

LOCAL EXTENSION

01. Browser Ingestion

Captures job postings directly within your browser session across 84+ supported ATS and job boards.

  • Architectural Invariant: Zero server-side scraping.
  • Bypasses Cloudflare / anti-bot blocks using existing authenticated session.
  • Supports DOM scrapers and JSON-LD structured schemas.
TECHNICAL IMPLEMENTATION
// extension/content-script.js
const payload = {
  url: window.location.href,
  title: extractField('title'),
  company: extractField('company'),
  descriptionHtml: extractField('description'),
  extractedAt: new Date().toISOString()
};
// Sent directly to local JobFoundry daemon
64-BIT HAMMING

02. SimHash Deduplication

Eliminates cross-posted duplicate jobs from multiple aggregators using text fingerprinting.

  • Normalizes company names, domains, and text whitespace.
  • Calculates 64-bit SimHash with configurable Hamming distance threshold.
  • Retains canonical master record with multi-source breadcrumbs.
TECHNICAL IMPLEMENTATION
// server/ingest/dedup.js
const hashA = computeSimHash(jobA.description);
const hashB = computeSimHash(jobB.description);
const distance = hammingDistance(hashA, hashB);

if (distance <= 3) {
  // Mark as duplicate of canonical job
  return deduplicate(jobB, jobA.id);
}
STRUCTURED JSON

03. LLM Fit Scorer

Scores candidate fit (0–100) using local LLMs (Ollama, vLLM) against your master profile.

  • Runs locally against Ollama or any OpenAI-compatible API.
  • Enforces strict JSON schema validation via Ajv.
  • Custom criteria weights: skills, experience level, remote policy.
TECHNICAL IMPLEMENTATION
{
  "fitScore": 88,
  "matchGrade": "A",
  "keyStrengths": ["Distributed Systems", "TypeScript", "PostgreSQL"],
  "gapAnalysis": ["Limited Go experience mentioned in posting"],
  "recommendation": "Strong apply"
}
TYPST / LATEX

04. Resume Tailoring

Generates tailored, ATS-compliant PDF and plain-text resumes highlighting matched requirements.

  • Deterministic output with zero LLM hallucination of false qualifications.
  • High-speed Typst compiler produces clean, pixel-perfect ATS PDFs.
  • Multi-theme templates suited for technical roles.
TECHNICAL IMPLEMENTATION
// server/tailor/engine.js
const tailoredResume = await generateTailoredProfile({
  masterProfile,
  targetJob,
  template: 'ats-modern'
});
await compileTypst(tailoredResume, 'output.pdf');
LOCAL-FIRST WEB

05. Kanban Dashboard

Organizes job applications across a responsive, multi-user local dashboard with application tracking.

  • Fast SQLite / Postgres storage with zero cloud lock-in.
  • Drag-and-drop status transitions from Discovered to Offer.
  • Direct link back to original job posting with paired tailored resume.
TECHNICAL IMPLEMENTATION
GET /api/jobs?status=scored&minScore=75
Response: 200 OK
[
  { "id": "job_9412", "title": "Staff Engineer", "score": 94, "stage": "READY_TO_APPLY" },
  { "id": "job_8204", "title": "Backend Lead", "score": 88, "stage": "APPLIED" }
]

Stage 1: Browser Ingestion

The companion browser extension (extension/) injects lightweight content scripts when visiting supported job boards and ATS domains.

  • Extraction Strategy: Prefers structured JSON-LD (schema.org/JobPosting) when present. Falls back to curated CSS selector trees for dynamic Single Page Applications (SPAs) like Workday or Ashby.
  • Payload Delivery: Sends parsed data via POST /api/jobs/ingest to the local daemon, accompanied by an authentication token generated during initial pairing.

Stage 2: SimHash & Deduplication Engine

Job postings are frequently syndicated across multiple aggregators (e.g., posted on Greenhouse, scraped by LinkedIn, and mirrored on Indeed). JobFoundry avoids duplicate scoring through a 64-bit SimHash locality-sensitive hashing algorithm:

  1. Tokenization & Normalization: Strips boilerplate disclosures (EEOC, copyright), converts text to lowercase, and extracts weighted n-grams.
  2. 64-bit Hash Fingerprint: Computes a compact bitvector where similar documents have small Hamming distances.
  3. Hamming Distance Clustering: If distance(hashA, hashB) <= 3, the job is identified as a cross-posting. The canonical posting is maintained while appending the new source URL as an alternative link.

Stage 3: LLM Fit Scoring & Criteria Evaluation

The scoring engine (server/scorer/) compares your master candidate profile against the job description using local LLMs (such as Llama 3 via Ollama or vLLM) or remote OpenAI-compatible endpoints.

  • Strict JSON Schema: Responses must satisfy an Ajv-validated schema ensuring valid integer scores (0–100), key matched qualifications, identified gaps, and actionable interview talking points.
  • Zero Hallucination: The model evaluates fit against provided profile facts only. It does not invent or assume credentials not present in your profile.

Stage 4: Resume Tailoring & ATS Export

Rather than rewriting your entire career history, the tailoring engine (server/tailor/) re-ranks and highlights your genuine experiences that directly align with the job's stated requirements.

  • Typst Compilation: Compiles clean, modern resumes using Typst, producing pixel-perfect PDF and plain-text ATS formats.
  • Deterministic Output: Generates verifiable, professional documents ready for submission.

Stage 5: Local Kanban Dashboard

The web interface (server/web/) provides a real-time Kanban board organized by pipeline status:

  • DISCOVERED: Newly ingested jobs awaiting automated processing.
  • SCORED: Jobs evaluated with fit scores and match grades.
  • READY_TO_APPLY: High-scoring jobs with generated tailored resumes.
  • APPLIED: Active applications with date tracking.
  • INTERVIEWING: In-progress interview stages and notes.