Job Application AI Tool

AI-powered suite that generates tailored job application emails and optimizes resumes using Google Gemini 2.5 Flash. Evolved from a single-purpose generator into a full Career Operating System with a Kanban pipeline, bulk JSON ingestion, and PostgreSQL-backed persistence.

Decoupled client-server architecture. A React.js SPA handles all UI state (tone, length, focus strategy, view mode). A FastAPI backend exposes two core endpoints (/generate for emails, /tailor-resume for resumes) plus CRUD routes for the application tracker. Multi-modal inputs are normalised server-side into a unified text context before being fed to the Gemini API. State is persisted via SQLAlchemy ORM — SQLite for local dev, PostgreSQL for production.

1. 01

   React.js Frontend (SPA)

   State managed via React hooks. Supports Kanban board (drag-to-transition stages), dense list table with badge filters, and a glassmorphic floating drawer for application detail views. Tone, length, and focus strategy selectors drive generation parameters.

2. 02

   FastAPI Backend (Async)

   Python async event loop via uvicorn. Non-blocking request handlers process multipart/form-data uploads concurrently. Routes: POST /generate, POST /tailor-resume, full CRUD for /applications. Alembic manages schema migrations.

3. 03

   Multi-Modal Ingestion Layer

   Accepts text strings, PDF byte streams (text extracted server-side), raw image buffers (passed directly to Gemini vision as inline data), and HTTP URLs (fetched and parsed server-side). No Tesseract or poppler binaries required — OCR is entirely offloaded to Gemini's vision API.

4. 04

   Gemini 2.5 Flash Orchestration

   Structured prompts enforce rigid JSON response schemas. POST /generate returns subject, body, keywords[], match_score, and tips[]. POST /tailor-resume returns header, summary, experience, keywords[], and match_score. Prompt templates are parameterised by tone (professional/concise/formal/etc.), length, and focus strategy.

5. 05

   Database Layer (SQLAlchemy + Alembic)

   SQLAlchemy ORM abstracts the storage backend. Single env variable switches between SQLite (sqlite:///./career_os.db) and PostgreSQL (postgresql://...). Alembic migration scripts track schema evolution. ACID-compliant transactions protect bulk import operations.

1. 01

   Eliminating server-side OCR dependencies

   Traditional OCR pipelines require libtesseract and poppler system binaries, massively increasing container footprint and creating memory bottlenecks under concurrent usage. Refactored to pass raw image byte buffers directly to Gemini's multi-modal API as inline data payloads. This offloads all OCR compute to Google's infrastructure, bringing local OCR cost to O(1) — zero system dependencies, zero memory overhead on the server.

2. 02

   Enforcing structured JSON from LLM outputs

   Raw Gemini responses were initially free-form text — unparseable by the frontend without post-processing fragility. Implemented a strict response_schema in the Gemini API call that enforces exact field names and types. Added a fallback parsing layer that extracts JSON from markdown code fences if the model wraps output in triple backticks. This eliminated all parsing failures in production.

3. 03

   Transitioning from ephemeral tool to stateful Career OS

   The original generator had zero persistence — every session was stateless. Adding the application tracker required a full relational schema, migration tooling, and a UI that supports two distinct view modes (Kanban and dense list) without a page reload. Implemented Alembic for schema versioning and a SQLAlchemy session factory that swaps backends via a single environment variable — no code changes required to go from SQLite to PostgreSQL.

• 01

  Offloading OCR to a vision LLM eliminates an entire class of server dependency problems — the tradeoff is latency, which is acceptable for async user-facing generation.

• 02

  Enforcing JSON schemas in LLM API calls is more reliable than post-processing free-form text — build the schema contract first, then write the prompt around it.

• 03

  SQLAlchemy's session abstraction makes database backend swaps genuinely painless — but you must commit to it from day one, not retrofit it after writing raw SQL.

• 04

  Kanban UI feels simple to design but is deceptively complex to implement correctly with optimistic updates and concurrent stage transitions.

• 05

  A well-scoped README is a product in itself — the open-source adoption rate correlates directly with setup friction.