# PrepMate: Your Private AI Interview Partner

Niranjan R Soorej — Mon, 05 Oct 2026 05:28:50 +0000

PrepMate: Your Private AI Interview Partner

The Problem

Preparing for software engineering interviews is often frustrating for one simple reason: generic practice doesn't feel like a real interview.

Most AI interview tools can ask questions, but they don't truly understand the candidate behind the resume. A candidate may know how to build a project but struggle to explain their technical decisions, defend a claim on their resume, or respond when an interviewer digs deeper.

I wanted to build something different for a real friend preparing for software engineering interviews:

an AI interviewer that actually knows their resume and adapts to them.

The Solution

PrepMate is a private AI interview partner powered by Google's open-weight Gemma model, running locally through Ollama.

The candidate uploads their resume, and PrepMate turns it into a structured candidate profile containing their:

Skills
Projects
Education
Coursework
Activities
Technical experience

Gemma then uses that profile to conduct a personalized interview.

Instead of asking:

"What is JWT?"

PrepMate can ask:

"You mentioned implementing JWT authentication in your Content Sharing Application. What security challenges did you consider when designing your JWT strategy?"

The interview then becomes adaptive.

The candidate answers → Gemma evaluates the answer → identifies weaknesses → generates a targeted follow-up → continues the interview.

What Makes PrepMate Different

1. Resume-Aware Interviews

PrepMate doesn't treat every candidate the same.

It uses the candidate's actual resume to determine what to ask.

For example, if a resume says:

"Optimized MongoDB queries using indexing for improved performance"

PrepMate can challenge that claim by asking:

"Which queries were slow before indexing, what index did you add, and how did you measure the improvement?"

The candidate has to defend what they actually wrote.

2. Adaptive Follow-Ups

PrepMate doesn't simply move from Question 1 → Question 2 → Question 3.

After every answer, Gemma evaluates:

Technical accuracy
Communication
Depth
Strengths
Weaknesses
Topics to revise

It then generates a targeted follow-up based on the candidate's weakest or most interesting area.

This creates a real interview loop:

Question
   ↓
Answer
   ↓
Gemma Evaluation
   ↓
Weakness Identified
   ↓
Targeted Follow-up
   ↓
Answer
   ↓
Deeper Evaluation

3. Resume Attack Mode

One of PrepMate's core ideas is Resume Attack Mode.

Instead of helping candidates memorize interview questions, PrepMate challenges the claims they put on their resume.

Claims such as:

"Optimized database queries"
"Implemented secure authentication"
"Built 10+ REST APIs"
"Solved 250+ DSA problems"
"Improved performance"

become opportunities for deeper technical questioning.

The goal isn't to accuse the candidate of lying.

The goal is to answer the question:

Can you actually defend the technical claims on your resume?

Why Gemma?

Gemma is at the core of PrepMate rather than being added as an optional feature.

The local Gemma model powers multiple stages:

Resume
   ↓
Gemma → Candidate Profile
   ↓
Gemma → Interview Question
   ↓
Candidate Answer
   ↓
Gemma → Evaluation
   ↓
Gemma → Follow-up
   ↓
Gemma → Resume Challenge
   ↓
Gemma → Final Interview Report

PrepMate runs Gemma 3 4B through Ollama locally.

This also gives the project an important privacy property.

Privacy First

A resume contains personal information.

Interview preparation can contain even more sensitive information: weaknesses, mistakes, confidence levels, and areas the candidate needs to improve.

Instead of sending this preparation data to a remote LLM API, PrepMate can run the AI locally:

Resume
   ↓
Your Computer
   ↓
Ollama
   ↓
Gemma

This makes PrepMate suitable for private interview preparation without requiring the candidate's resume and answers to leave their machine.

Technical Architecture

Frontend

React
Vite
Tailwind CSS
Axios

Backend

Python
FastAPI

AI

Gemma 3 4B
Ollama

Resume Processing

PyMuPDF
Tesseract OCR
Pillow

Storage

Browser localStorage for interview session persistence

Architecture

                  ┌───────────────┐
                  │   Resume PDF  │
                  └───────┬───────┘
                          ↓
                 ┌─────────────────┐
                 │ PyMuPDF + OCR   │
                 └────────┬────────┘
                          ↓
                 ┌─────────────────┐
                 │      Gemma      │
                 │ Resume Profiler │
                 └────────┬────────┘
                          ↓
                 ┌─────────────────┐
                 │ Candidate       │
                 │ Profile         │
                 └────────┬────────┘
                          ↓
                 ┌─────────────────┐
                 │ Interview       │
                 │ Engine          │
                 └────────┬────────┘
                          ↓
                    Question
                          ↓
                       Answer
                          ↓
                 ┌─────────────────┐
                 │ Gemma Evaluator │
                 └────────┬────────┘
                          ↓
              ┌───────────┼───────────┐
              ↓           ↓           ↓
           Scores     Weaknesses  Follow-up
                                      ↓
                              Next Question

What My Friend Said

I built this for my friend Athul K, who is preparing for placements. Generic interview practice wasn’t working for him because it didn’t provide enough personalized feedback or simulate the pressure of a real interview.

After trying it, he said: “It felt much more like a real interview, and the feedback actually helped me understand what I need to improve.”

What I Learned

Building PrepMate highlighted an important distinction between an AI chatbot and an AI application.

A chatbot can generate a question.

An interview system needs to maintain context, history, evaluation, and adaptation.

The difficult part wasn't simply connecting Gemma to an API. It was designing the feedback loop around the model:

Context → Question → Answer → Evaluation → Decision → Follow-up

That loop is what turns a model into an actual interview partner.

Future Improvements

Future versions can extend PrepMate with:

Voice-based interviews
Interview performance analytics
Long-term preparation tracking
More advanced resume claim analysis
Company-specific interview modes
Interview difficulty progression
Detailed final preparation plans

But the current version focuses on the core experience:

Upload your resume. Face an interviewer that knows it. Defend what you wrote. Learn where you need to improve.

Tech Stack

React + Vite + Tailwind
          │
          ▼
       FastAPI
          │
          ▼
       Ollama
          │
          ▼
     Gemma 3 4B
          │
          ▼
Resume Profiling
Interview Generation
Answer Evaluation
Adaptive Follow-ups
Resume Attack

Running Locally

Clone the repo first:

git clone https://github.com/NiranjanRSoorej06/Prepmate.git
cd Prepmate

Start Gemma

ollama pull gemma3:4b

Start the Backend

cd backend
source .venv/bin/activate
uvicorn main:app --reload --port 8000

Start the Frontend

cd frontend
npm install
npm run dev

Then open:

http://localhost:5173

Demo Flow

Upload a resume.
Let Gemma analyze the candidate profile.
Select the target role and interview type.
Start the interview.
Answer a personalized question.
Receive technical evaluation.
Follow the targeted question generated from the weakness.
Continue the adaptive interview.
Use Resume Attack Mode to defend claims from the resume.
Refresh the browser and restore the interview session.

Why Open Models Made This Possible

PrepMate only works the way it does because Gemma is open-weight.

Your resume never leaves your machine. A resume holds your name, projects, and contact details, and interview practice holds your weaknesses. With a closed API, all of that goes to a server you don't control. With Gemma on Ollama, every model call goes to localhost, and the interview keeps working with Wi-Fi switched off.
It costs nothing to run. Practice interviews are repetitive by nature: five questions, five evaluations, five follow-ups, over and over. A paid API would charge for every attempt. A local model lets my friend practice as many times as they want.
I could shape the model's behavior. Because I control the prompts and the model, I could make Gemma act as an evaluator instead of a chatbot and return structured scores, weaknesses, and follow-ups.
It runs on a normal laptop. Gemma 3 4B is small enough for a student laptop, even on CPU, which is where most placement candidates are practicing.

Why PrepMate?

PrepMate doesn't just ask interview questions.

It asks:

"What did you claim you know, and can you actually defend it?"

It turns a static resume into a dynamic interview.

And because the intelligence runs locally with Gemma, the candidate can practice privately on their own machine.

DEV Community: Niranjan R Soorej

# PrepMate: Your Private AI Interview Partner