PrepMate: Your Private AI Interview Partner
GitHub: NiranjanRSoorej06/Prepmate
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.
Top comments (0)