Hacktoberfest weekend Challenge Completed

Darsh Bansal — Sun, 04 Oct 2026 22:23:15 +0000

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

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.

DEV Community: Darsh Bansal