"PrepMate AI: a local AI interviewer built for my friend"

**

What I Built**

I built PrepMate AI, a local AI-powered interview practice partner for my college friend who is preparing for software development interviews.

While preparing for interviews, he found it difficult to practice realistic mock interviews because he did not always have someone available to ask technical questions and give feedback on his answers.

I wanted to build something that solved that specific problem instead of making another general-purpose chatbot.

So I built PrepMate AI — an AI interviewer that can conduct a technical interview, evaluate answers, ask follow-up questions, and give a final performance report.

The idea is simple:

Choose a topic
↓
Choose difficulty
↓
Start interview
↓
AI asks a question
↓
Answer the question
↓
AI evaluates the answer
↓
Follow-up question
↓
Final performance report

Demo

Live URL :[https://prep-mate-ai-seven.vercel.app]
The demo shows the complete interview flow:

Open PrepMate AI

Select the interview category
Choose the difficulty
Choose the number of questions
Start the interview
Receive an AI-generated question
Submit an answer
Receive AI evaluation and feedback
Continue with follow-up questions
Complete the interview
View the final performance report

I also show the local AI setup using Ollama and the qwen3:4b model.

`Github
{% embed https://github.com/Ganesh-Bharambe29/PrepMate-AI %}

`

The repository contains the complete frontend, backend, interview logic, Ollama integration, prompts, and setup instructions for running the project locally.

*How I Built It
*
PrepMate AI is a full-stack application built around a locally running open-weight model.

The main technologies I used are:

Frontend
React + Vite

Backend
Node.js + Express

AI
Ollama + Qwen3 4B

Communication
REST API

The architecture is:
┌─────────────────────┐
│ React Frontend │
│ │
│ Setup / Interview │
│ Feedback / Report │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Node.js + Express │
│ │
│ Interview APIs │
│ Prompt Handling │
│ Response Parsing │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Ollama │
│ localhost:11434 │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Qwen3 4B │
│ Local Inference │
└─────────────────────┘

1. Interview setup

The candidate first chooses the interview configuration.

Category
→ Java
→ DSA
→ DBMS
→ Computer Networks
→ Operating Systems
→ JavaScript
→ React
→ Full Stack Development

Difficulty
→ Easy
→ Medium
→ Hard

Questions
→ 5
→ 10
→ 15

2. AI-generated questions

When the interview starts, the backend asks Qwen3 to behave as a technical interviewer.

The model generates a question based on:

[- Selected category

• Difficulty
• Interview context
• Previous questions and answers where relevant](url)

The application presents one question at a time so the interview feels more like a real conversation rather than a static list of questions.

3. Answer evaluation

After the candidate submits an answer, PrepMate sends the answer and relevant interview context to Qwen3.

The AI evaluates the response and returns information such as:

1. Score
2. Verdict
3. Strengths
4. Issues / Missing points
5. Ideal answer
6. Follow-up question

That information is then displayed in the application as structured feedback.

The goal is not to tell the candidate that every answer is good.

The interviewer should identify what was correct, what was missing, and what the candidate should improve.
**

1. Follow-up questions**

This is one of the parts I wanted to make more realistic.

A normal practice platform might do:
Question
↓
Answer
↓
Next unrelated question

PrepMate tries to make the flow more conversational:
Question
↓
Answer
↓
Evaluation
↓
Follow-up based on the answer

5. Final performance report

Once the interview is complete, PrepMate generates a final report.

The report summarizes the candidate's performance and provides question-by-question feedback.

It includes information such as:

• Overall Performance
• Average Score
• Strong Areas
• Areas to Improve
• Recommended Topics
• Question-by-question Feedback

Why Does Open Innovation Matter?

For PrepMate AI, using an open-weight model locally was not just a technology choice. It changed how I could build the application.

The model runs locally

I am running Qwen3 4B locally through Ollama on my own laptop.

The model was downloaded once and can then be used through the local Ollama API.

That means the core interview experience can work without depending on a remote proprietary AI API for each question.

More control over the AI

Because the model is part of my local development environment, I can control the prompts, interview context, conversation history, evaluation format, and application logic around it.

The AI is not simply a black-box button inside the application.

I can change the interviewer behavior by changing the prompts and the way context is passed to the model.
**
Model flexibility**

The application is built around Ollama rather than tightly coupling the code to one proprietary provider.

That means the model layer can evolve as I experiment with other compatible open-weight models and configurations.

Lower barrier to experimentation

Local inference also made it possible for me to keep developing and testing the core AI functionality without needing a paid request for every test.

For a student project that I wanted to build over a weekend, that mattered.

Why this matters for PrepMate?

Interview answers can contain personal information about a candidate's preparation, weaknesses, and learning progress.

With local inference, the AI processing for the local setup happens on the machine running the model rather than requiring those conversations to be sent to a proprietary cloud AI service.

That was one of the main reasons I wanted the AI to run locally.