ResumeForge：以私隱為先、採用本地開放權重模型的 AI 履歷分析工具

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Every time someone applies for a job today, they are handed the same advice: "Tailor your resume to the job description." But behind that simple advice is a frustrating dilemma.

Existing commercial resume optimization tools charge $20 to $40 a month. Worse, they demand that you upload your entire professional life—phone numbers, employment history, company names, side projects, references, and education—onto their remote servers. Once uploaded, your career data is fed through third-party proprietary APIs, stored in external databases, and often retained for downstream model training.

For developers, privacy-conscious professionals, freelancers, and students on tight budgets, this is an unacceptable trade-off.

I built ResumeForge to solve this.

ResumeForge is an AI-powered resume analysis and tailoring platform that runs 100% locally on your machine using open-weight models. No cloud AI inference. No subscriptions. Zero data leaving your computer.

What it does:

1. Upload & Parse: You upload your existing resume (.pdf or .docx) and paste any target Job Description (JD).
2. Local AI Engine: ResumeForge extracts the content, parses the role requirements, and feeds them directly to an on-device open-weight model through Docker Model Runner.
3. Rigorous Calibrated Analysis:
   • Fit Score (0–100): A realistic, calibrated score with an honest 1–2 sentence justification (no false inflation or polite cheerleading).
   • Matching vs. Missing Skills: Side-by-side gap analysis pinpointing hard skills, frameworks, and domain knowledge from the JD that are absent in your resume.
   • Strengths & Candid Gaps: Concrete, experience-backed highlights contrasted with critical areas of concern.
   • Targeted Section-by-Section Edits: Granular, actionable suggestions mapped directly to your resume sections (Experience, Summary, Projects, Skills).
   • High-Priority ATS Keywords: Exact phrases and acronyms from the JD to help navigate Applicant Tracking Systems.
4. Side-by-Side PDF Inspection & History: View your original resume PDF rendered inline directly alongside your AI audit, with full authentication and persistent session history.

Who would pay for it?

• Privacy-Sensitive Tech Workers & Executives: Engineers, defense/health contractors, and leaders whose work history includes confidential projects, proprietary IP, or non-disclosure constraints.
• Bootcamp Grads & Career Changers: Job seekers needing rapid, iteration-heavy feedback across 50+ job applications without paying per-token or per-month cloud API fees.
• Freelance Recruiters & Career Coaches: Consultants who want a private, white-label, zero-marginal-cost audit workstation to review client materials locally without data compliance liabilities.

As a side-hustle product, ResumeForge can be delivered as a packaged local-first desktop app, a self-hosted workspace for recruiting agencies, or a freemium desktop utility with premium local workflow templates.

Demo

Check out the project demo:

• Live Demo Vedio: Live Demo
• Demo Preview:

Landing & Auth	Analysis Engine	Full Audit Results

Code

The entire codebase is open-source and ready to clone:

📸 Screenshots

Demo Screenshots

Landing Page	Analyze Page	Results View

History Page	Resume PDF Viewer

✨ Features

🧠 Intelligent Analysis

• Fit Score (0–100) with strict scoring rubric and honest rationale — the AI is calibrated to never blindly inflate scores
• Score Explanation — a 1–2 sentence justification of exactly why that score was given
• Matching Skills — skills that appear in both your resume and the job description
• Missing Skills — critical requirements from the JD that are absent from your resume
• Key Strengths — concrete, experience-backed strengths relevant to the role
• Areas of Concern — candid gaps and red flags — no sugarcoating
• Targeted Section Improvements — actionable edits referencing real resume sections (Experience, Skills, Summary, Projects, Certifications)
• …

GitHub Repository: https://github.com/NegiSushant/ResumeForge

How I Built It

ResumeForge is architected around the premise that commodity consumer hardware is now capable of running production-grade AI analysis if prompt design, parsing pipelines, and local inference orchestration are done right.

┌────────────────────────────────────────────────────────┐
│                      Next.js 16                        │
│             App Router + Tailwind CSS                  │
└───────────────▲────────────────────────▲───────────────┘
                │                        │
       Upload & Parse Stream      Session & History
                │                        │
┌───────────────▼──────────────┐ ┌───────▼───────────────┐
│ pdfjs-dist / mammoth         │ │ MongoDB Atlas / Local │
│ (Client / Server Extractors) │ │ (Mongoose + NextAuth) │
└───────────────┬──────────────┘ └───────────────────────┘
                │
         Extracted Text
                │
┌───────────────▼────────────────────────────────────────┐
│ OpenAI SDK (BaseURL: http://localhost:11434/v1)        │
└───────────────┬────────────────────────────────────────┘
                │
┌───────────────▼────────────────────────────────────────┐
│ Docker Model Runner (DMR)                              │
│ └── ai/gemma3:1b-q4_K_M (Open-Weight Gemma 3 1B)       │
└────────────────────────────────────────────────────────┘

1. The Open-Source AI Core: Gemma 3 (1B) & Docker Model Runner

Instead of piping text to remote proprietary endpoints, ResumeForge delegates inference to Google's open-weight Gemma 3 (1B) (ai/gemma3:1b-q4_K_M), quantized at 4-bit precision.

Inference is managed via Docker Model Runner (DMR). This allowed me to:

• Expose an OpenAI-compatible local HTTP endpoint (http://localhost:11434/v1 or native DMR port) with zero external setup friction.
• Decouple model life-cycle and GPU/CPU acceleration from the Node.js runtime.
• Use the standard openai Node SDK inside Next.js route handlers simply by pointing baseURL to the local Docker daemon.

2. Engineering Around a 1B Parameter Model: Honest Lessons

Working with a lightweight 1-billion parameter model taught me a huge amount about constraint-driven AI engineering.

A 1B model is lightning fast and runs with a negligible memory footprint (~1.2 GB RAM), but it can easily wander or drop structured fields if given ambiguous instructions. To get deterministic, publication-grade resume evaluations out of Gemma 3 1B:

• Strict JSON-Only Guardrails: I engineered an exacting system prompt that forces raw JSON output wrapped in a single code block, complete with an explicit scoring rubric (e.g., 70–84: Strong candidate, minor gaps; 50–69: Moderate fit, notable missing skills).
• Anti-Sycophancy Calibration: Small models tend to be agreeable and hand out 95% scores. I explicitly calibrated the rubric to penalize missing prerequisites and prioritize brutal honesty.
• Robust Schema Parsing & Fallbacks: Responses pass through a regex-assisted JSON cleaner and Zod schema validation to handle edge-case markdown formatting quirks before hitting the frontend.

3. Full-Stack Data & Authentication Pipeline

• Next.js 16 (App Router) & TypeScript: High-performance server actions and API route handlers for document ingestion.
• Document Extractors: pdfjs-dist for raw text and structure parsing from PDFs, and mammoth for parsing .docx resumes cleanly.
• MongoDB & NextAuth.js v5: Handles secure credential authentication (bcrypt-hashed) and persists resume metadata, extracted content, fit scores, and historical audits so users can track improvements across multiple versions of their CV.

Why Does Open Innovation Matter?

Open innovation is not just an alternative deployment model; for an application like ResumeForge, it is the only model that aligns with user ethics and long-term viability.

1. Privacy Is Not a Feature—It Is the Product

Career data is intimate. Resumes reveal your identity, residential address, compensation progression, side ventures, and clearances.

When you use proprietary SaaS resume checkers powered by closed APIs, you are forced to trust a chain of third parties not to log, leak, or train on your identity. Open innovation means the model weights live on your disk, the inference executes inside your memory, and the network cable could literally be unplugged while your resume is analyzed.

2. Eliminating the "API Tax" on Side Hustles

Building an AI side hustle on closed APIs creates an existential vulnerability: variable marginal cost. Every time a user uploads a 4-page resume and a long JD, you pay token costs. If a user tests 20 resumes, your margins evaporate.

With open-weight models like Gemma 3 running locally or self-hosted:

• Marginal inference cost is $0.00.
• There are no surprise cloud bills at the end of the month.
• Builders can price their product as a one-time purchase or lifetime license instead of forcing users into recurring subscriptions.

3. Democratizing Career Advancement

A student in an emerging market or an unemployed worker should not have to pay $30/month just to understand why their resume is failing ATS filters. Open-weight models level the playing field, making world-class career analysis accessible to anyone with a modest laptop.

My Agent Session

During development, agentic pair programming helped scaffold the Next.js 16 App Router endpoints, optimize the Docker Model Runner configurations, and iterate through prompt calibrations for Gemma 3's output parsing.

Prize Categories

I am entering ResumeForge into the following categories:

• Best Use of Gemma: Built directly around Google's open-weight Gemma 3 (1B) model (ai/gemma3:1b-q4_K_M), pushing the limits of what a compact 1B model can achieve through calibrated system prompts and structured JSON enforcement.
• Best Use of MongoDB Atlas: Utilizing MongoDB (Mongoose ODM) to power secure user authentication, resume metadata storage, and persistent historical resume-to-job matching audits.
• Best Use of Docker / Local Inference: Containerized local AI orchestration through Docker Model Runner, creating a seamless, zero-cloud bridge between open-weight models and web runtimes.
• Overall / Side Hustle Track: A complete, privacy-respecting product concept addressing a massive consumer pain point with zero marginal inference costs.