Resume Studio

The product problem

Most resume tools hide their reasoning behind a single score or ask users to trust an unconstrained rewrite. Resume Studio makes the workflow inspectable: users can see required and preferred signals, evidence strength, title and experience checks, individual recommendation priorities, and the exact words an edit would change.

Keep scoring deterministic

The baseline score does not require an LLM. I designed a documented scoring model that parses job-posting context, weights required qualifications above preferred signals, searches accomplishment lines for evidence, and combines ATS coverage with recruiter quality, technical fit, and leadership signals. Identical inputs produce identical results.

• Multi-word concepts are extracted before individual technologies to preserve meaning.
• Required, responsibility, leadership, preferred, and company signals receive explicit weights.
• Evidence is stronger when a skill appears in an accomplishment with clear action context.
• Priority scoring exposes job relevance, impact, ownership, clarity, alignment, and truthfulness risk.

Use AI inside deterministic guardrails

Ollama is the default local provider, with Groq and OpenAI available as optional alternatives. The client never accepts a model-returned resume wholesale. Models return structured before-and-after changes that are reconciled against the current draft, localized to an exact section or role, and validated before the user can apply them.

• Preflight tools inspect resume structure and find supporting evidence before generation.
• Postflight validation rejects no-op changes, misplaced edits, role-boundary violations, and unsupported claims.
• Unsupported numeric claims are blocked rather than presented as plausible achievements.
• A constrained repair pass can retry rejected edit intent against the current safe draft.

Build an editor users can trust

Suggestions remain proposals. Users can apply edits individually, accept all valid edits, inspect word-level differences, undo changes, and re-score the current draft. Idempotent application logic prevents duplicate acceptance, while highlighted previews remain visually separate from clean exports.

• Exact changed-word ranges make model output reviewable instead of opaque.
• Guided gap integration asks users to attest to real experience before adding a missing skill.
• Resume cleanup normalizes PDF extraction artifacts without erasing document structure.
• Exports support TXT, DOCX, and newly rendered PDF documents.

Handle documents as real data

The ingestion layer supports PDF, DOCX, and TXT resumes as well as pasted text. DOCX editing preserves the original package and paragraph-level formatting where possible; PDF input remains a reference while the editable draft is safely rendered into a new PDF. Those boundaries are explicit because arbitrary documents cannot be edited losslessly.

Design local-first persistence

The product stores profile information and tracked applications in a local SQLite database, enables foreign keys and WAL mode, and requires no separate database server. Resume analysis can use a locally hosted Ollama model, giving users a functional private path without sending career data to a hosted AI provider.

• Real URL routes share active analysis through a typed workspace provider.
• The application tracker stores role, company, status, score, notes, URL, and timestamps.
• Server-side job import reads supported public postings and structured metadata.
• Provider configuration is isolated behind environment variables and server routes.

Engineer for regression resistance

Resume transformation is deceptively risky: a small parsing change can move an edit into the wrong employer, duplicate text, or damage formatting. I built regression coverage around scoring, malformed PDF characters, role boundaries, duplicate prevention, section placement, word diffs, AI reconciliation, and formatting cleanup, then paired tests with production TypeScript builds.

Tradeoffs and rejected shortcuts

An LLM-only score would be faster to prototype, but it would make comparisons unstable and explanations difficult to test. Editing a model-returned resume wholesale would produce a smoother demo, but it would weaken user control and make unsupported changes harder to detect. I accepted more parsing, reconciliation, and validation work to keep the score reproducible and every edit attributable.

• Local inference improves privacy but requires users to manage model availability and performance.
• Hosted providers improve accessibility but introduce data-handling and availability dependencies.
• Preserving source document structure limits how aggressively arbitrary files can be transformed.
• Structured suggestions constrain model freedom in exchange for safer application and testing.

What I learned

Document AI is primarily a data-integrity problem. The difficult work is not asking a model for better prose; it is locating evidence, preserving role boundaries, reconciling suggestions with a changing draft, and exporting without silently damaging structure. Separating deterministic judgment from generative assistance made both the user experience and the test strategy clearer.

Senior engineering signal

The core design decision was to separate what must be reproducible from what benefits from generative assistance. Deterministic analysis owns scoring and safety; AI contributes bounded suggestions; the user owns acceptance. That division produces a more explainable, testable, and trustworthy product than an AI-first rewrite pipeline.