I built PrepMate, an AI interview coach for a friend preparing for SDE interviews 🤝

This is my submission for the Hacktoberfest Weekend Challenge: Build for a Friend.

What I Built

I built PrepMate, a privacy-first AI interview preparation assistant for a friend preparing for software engineering interviews.

The problem is simple: interview preparation is often generic. A candidate may have a specific resume, a specific target job, and specific weaknesses, but still practice the same questions as everyone else.

PrepMate makes the preparation personalized.

The user provides:

• A resume
• A target job description

PrepMate then analyzes the candidate against the role and provides:

• Strengths
• Skill gaps
• Relevant interview topics
• A personalized preparation plan

But I didn't want it to stop at resume analysis.

PrepMate also conducts an adaptive mock interview. It evaluates the candidate's answer and uses that evaluation to decide what kind of question should come next.

Demo

Demo video: Watch the PrepMate demo

The demo shows the complete flow:

1. Upload a resume and job description
2. Analyze the candidate's fit
3. Start the mock interview
4. Answer the first question
5. Receive an AI evaluation
6. Generate an adaptive second question
7. Complete the interview
8. Receive the final feedback report

How It Works

The main pipeline is:

Resume + Job Description → PDF Extraction → RAG → Gemma → Personalized Analysis → Adaptive Interview → Final Report

The project uses:

• Next.js + TypeScript for the frontend
• FastAPI + Python for the backend
• FAISS for vector search
• Sentence Transformers for embeddings
• Ollama + Gemma 2B for local AI inference
• pypdf for resume extraction

The resume and job description are processed in memory.

Adaptive Interview

The interview is intentionally adaptive rather than simply generating a fixed list of questions.

After each answer, PrepMate evaluates:

• Correctness
• Depth
• Clarity
• Completeness

Based on the evaluation, the system can choose strategies such as:

• Reinforce a weakness
• Ask a follow-up
• Increase difficulty
• Continue on the same topic
• Move to a new topic

The current MVP runs a focused 2-question interview followed by a final report.

Why Open-Source AI?

I wanted the core AI functionality to work without depending on a paid proprietary LLM API.

PrepMate uses the open-weight Gemma 2B model locally through Ollama.

This makes the project:

• Local
• Free to run
• More privacy-friendly
• Easier to experiment with and inspect

The RAG pipeline also runs locally using FAISS and Sentence Transformers.

Prize Category

Best Use of Gemma: PrepMate uses the open-weight Gemma 2B model locally through Ollama for resume and job-description analysis, interview question generation, answer evaluation, and personalized feedback.

Gemma is not just used as a simple chatbot. It is integrated into the core interview-preparation workflow, while the deterministic Python logic controls the adaptive interview strategy.

Privacy

Resumes can contain sensitive personal information, so privacy was an important design consideration.

PrepMate:

• Processes the resume in memory
• Does not permanently store the uploaded PDF
• Keeps interview session state in memory
• Uses local Ollama/Gemma for AI inference
• Does not require a paid LLM API

The demo uses fictional sample candidate data.

What I Learned

Building PrepMate helped me understand how different AI components fit together into an actual product rather than just calling an LLM.

I worked with:

• PDF document processing
• Embeddings and vector search
• RAG
• Local LLM inference
• Structured JSON generation
• Adaptive interview logic
• FastAPI APIs
• Next.js frontend integration
• Testing an AI-powered application end-to-end

One important design choice was keeping the interview strategy deterministic in Python while using Gemma for natural-language question generation and evaluation.

This makes the adaptive behavior easier to understand, test, and debug.

GitHub

💻 Source code: https://github.com/Sri-Indu/PrepMate

The project is open source and includes the implementation, setup instructions, and tests.

Current Limitations

This is an MVP, so it currently has:

• 2 interview questions per session
• No authentication
• No persistent interview history
• No voice input
• No production deployment
• Local Ollama/Gemma setup required

These are intentional scope limitations for the challenge rather than unfinished core functionality.

What's Next

Future versions could include:

• Longer adaptive interviews
• Voice-based interviews
• Persistent candidate history
• More advanced interview strategies
• Production deployment
• Support for additional open-weight models

Final Thoughts

I built PrepMate because I wanted to solve a real problem for someone preparing for SDE interviews instead of building another generic AI chatbot.

The goal is simple:

Give a candidate a preparation plan based on their actual profile, then help them improve through an adaptive interview.

Building this project also helped me understand how RAG, embeddings, local LLMs, structured generation, and application logic can work together as one complete AI product.

Built for the Hacktoberfest 2026 Build for a Friend Challenge 🤝