LocalCV — Your Career Data. Your AI. Your Resume.
This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend
What I Built
I built LocalCV, a local-first AI career management and resume generation application for a friend who was tired of maintaining different versions of their resume for every internship and job application.
The problem was simple: their career information was scattered across certificates, project repositories, documents, portfolios, and old resumes. Every new job application meant manually deciding which projects, skills, certifications, and experiences were relevant.
So I built a personal career vault that stores everything in one place and uses local AI to turn that information into a targeted resume.
The workflow is:
Build your career profile once
↓
Paste a job description
↓
Local AI analyzes it
↓
Selects the most relevant evidence
↓
Generates a tailored resume
↓
Export PDF
LocalCV also turns the same career profile into a personal portfolio, so the user maintains their information in one place instead of updating a resume and portfolio separately.
Most importantly, the career profile stays local.
There is no account, no mandatory cloud database, and no requirement to send someone's entire professional history to a proprietary AI service.
Demo
GitHub: https://github.com/Darsh-Bansal/LocalCV.git
The application can be run locally and used with a locally hosted Gemma model through Ollama.
The demo
I start with a single career profile containing projects, certifications, education, experience, and skills.
Then I paste a job description.
LocalCV analyzes the requirements and determines which parts of the existing profile are most relevant.
For example, the same career profile can produce a different resume for:
- a Software Engineering internship
- an AI/ML internship
- a Quantitative Research internship
The underlying facts don't change. What changes is which evidence is emphasized and how it is presented.
The AI is explicitly instructed not to invent qualifications, experience, projects, technologies, achievements, or metrics.
How I Built It
LocalCV is a local-first web application built around Gemma, Google's open-weight model, running locally through Ollama.
The architecture is intentionally simple:
LocalCV
│
┌─────────┴─────────┐
│ │
Career Vault Portfolio
│
Local DB
│
Job Description
│
▼
Local AI Service
│
Gemma + Ollama
│
▼
Structured Resume Data
│
▼
Resume Renderer
│
▼
PDF
The application uses a React-based interface and local browser storage for the career profile.
Gemma isn't asked to blindly "write a resume."
Instead, the application gives the model:
- The user's existing career profile.
- The target job description.
- The desired resume style.
Gemma identifies the relevant requirements and selects the strongest evidence from the user's actual career history.
The model then returns structured resume data, which the application renders into the final resume.
This separation is intentional:
AI decides what is relevant. The application decides what gets rendered.
That also gives us a strong defense against hallucinations. The model is instructed that the career profile is its only source of factual information and that it must never invent qualifications or achievements.
Why Does Open Innovation Matter?
This is the part of LocalCV that matters most to me.
A resume contains surprisingly personal information:
- education
- employment history
- projects
- achievements
- certifications
- contact information
- career goals
I didn't want the core experience of maintaining that information to depend on uploading it to a company's cloud infrastructure.
With LocalCV, the career profile can stay on the user's computer and the AI can run locally through an open-weight model.
That changes what is possible.
Privacy
The user can use their complete career history without needing to send it to a third-party AI API.
Ownership
The career database belongs to the user. It can be exported as JSON and moved to another installation.
Model freedom
Because the AI layer is built around a local model rather than a proprietary API, the model can be replaced or experimented with.
Transparency
The prompting and resume-selection logic are part of the application rather than an opaque service.
Offline potential
Once the application, dependencies, and model are installed, the core workflow can operate locally without requiring an internet connection.
For this particular project, open innovation isn't just a technical choice.
It is part of the product's purpose.
The person whose career information is being processed should have a meaningful choice about where that information goes and which AI processes it.
What I Learned
The most interesting part of building LocalCV wasn't generating text.
It was figuring out where the AI should and shouldn't be involved.
My first instinct was to have the model generate the entire resume.
Instead, I ended up treating the model more like a reasoning layer:
Career Data → AI Selection → Structured Data → UI Rendering
That makes the system easier to reason about and reduces the chance that a polished-looking resume contains something that the user never actually did.
It also made the project feel less like an "AI wrapper" and more like an application where AI solves a specific problem.
My Agent Session
<!-- Add your DevRelay agent session here if you saved one. -->
Prize Categories
Best Use of Gemma
LocalCV is built around Gemma as its local open-weight AI model.
Gemma performs the core resume-tailoring task: analyzing a job description, matching it against the user's career profile, and selecting the most relevant evidence.
The application is designed so that the AI remains useful without requiring a proprietary cloud model.
Built for a friend who just wanted to stop rewriting the same resume over and over again.
Your career data. Your AI. Your resume.
Top comments (0)