The Problem

Job boards are noisy, and black-box AI apply tools give no visibility into why a role is worth pursuing. JustHireMe addresses this by providing a local-first workbench that scrapes leads from multiple sources, filters out low-quality postings, scores fit with explainable rules, and generates tailored application materials—all without sending your data to a third-party service.

What This Does

The repository is a collection of five self-contained projects, not a single codebase. The core is backend/ (41 Python files), which implements the scraping, ranking, and generation agents. src/ and src-tauri/ form the desktop frontend (React + Tauri), while Designs/ contains a Remix-based UI mockup and website/ is a separate marketing site.

Key agents live in backend/agents/: scout.py handles lead discovery, scoring_engine.py ranks fit, generator.py produces resumes and cover letters, and actuator.py handles experimental browser automation (disabled by default). The backend/main.py file is the API entry point, exposing endpoints for manual lead creation, scanning, and feedback.

How It Is Wired

Execution starts at backend/main.py, which defines the FastAPI server. The call graph shows create_manual_lead (line 799) reaches 48 functions, scan (line 1039) reaches 36, and read_lead_form (line 1747) reaches 29—these are the primary entry points. From there, control flows into backend/agents/lead_intel.py (owns lead_id, clean_text), backend/db/client.py (owns add, open_table, create_table), and backend/llm.py (owns model configuration).

The most-connected modules are src/types (25 modules depend on it) and src/components/Icon (16 dependents)—both are stable hubs with zero outgoing edges. The highest-blast-radius functions are search (called from 29 places), post (21), and broadcast (19). The shortest path from an entry point to an external effect is create_manual_lead -> manual_lead_from_text -> lead_id, which hits hashlib.md5 in two hops. Network calls leave via httpx.get in read_form (from backend/agents/actuator.py), also two hops from read_lead_form.

The file-by-file map: backend/db/client.py owns all database effects; backend/agents/ingestor.py handles file reads and hashing; backend/llm.py is the single point for model inference; backend/main.py is the orchestrator that wires everything together.

How To Use It

Setup: The repo uses pyproject.toml (Python 3.13) and package.json (npm). Install backend dependencies with uv sync or pip install -e backend/, and frontend with npm install.

Configuration: Copy .env.example to .env and set API keys for LLM providers (OpenAI, Anthropic, or Gemini) and any scraper credentials.

Running it: Start the backend with python backend/main.py, which launches the FastAPI server. The frontend requires a Tauri build (npm run tauri dev).

Real-World Use

A user configures their profile in the Settings modal, then runs a scan. The scout.py agent pulls leads from configured sources, scoring_engine.py assigns explainable fit scores, and generator.py produces a tailored resume PDF and cover letter. The user reviews the pipeline view, rejects poor leads, and the feedback loop updates the ranker for future scans.

Code Health & Issues

Static analysis identified 57 findings (8 high, 49 medium). High-severity issues include:

  • High - Hub modules - src/types.ts and src/components/Icon.tsx have 25 and 16 dependents respectively; changes here ripple widely.
  • High - Deep nesting - backend/agents/actuator.py, src/views/ProfileView.tsx, and src-tauri/src/lib.rs reach indentation depth 8.
  • High - Duplicated code - 106 repeated 6-line blocks across 21 files, notably Sidebar.tsx and sidebar.jsx.
  • High - Oversized files - backend/db/client.py has 1372 lines; backend/main.py and ApprovalDrawer.tsx are similarly large.

Additional SDLC findings: third-party GitHub Actions are pinned to tags, not commit SHAs (.github/workflows/ci.yml); backend/main.py interpolates values into SQL strings; CI workflows lack least-privilege token permissions and persist-credentials: false.

The Bottom Line

The architecture is sound—local-first, explainable scoring, and a clear separation between agents and the API layer. The main risks are the oversized main.py and db/client.py, plus the duplicated frontend code. It's alpha-quality but hackable, and worth exploring if you want transparent job-search tooling you control.