# InterviewBuddy AI

> Source: <https://dev.to/prathamesh_desai_/interviewbuddy-ai-42n0>
> Published: 2026-10-04 16:03:58+00:00

*This is a submission for the [Hacktoberfest Weekend Challenge: Build
for a
Friend](https://dev.to/challenges/hacktoberfest-weekend-2026-10-01)*

I built **InterviewBuddy AI**, a beginner-friendly AI mock interview

partner for a friend who is preparing for **Data Analyst, Data Executive, and MIS Executive interviews**.

The problem was simple: finding interview questions is easy, but finding

someone who is consistently available to conduct a realistic interview,

ask follow-up questions, and give useful feedback is much harder.

InterviewBuddy AI turns a resume into a personalized interview practice

session.

A user can:

The goal is not to replace a real interviewer. It is to give my friend

an always-available practice partner so they can practice repeatedly

without needing another person to be available every time.

**Local demo:** Run the project locally using the instructions in the

GitHub README.

For the final submission, include a short video showing: resume upload

→ role selection → AI-generated questions → answering → AI feedback →

final report.

**GitHub repository:** ([https://github.com/prathamesh-1983/InterviewBuddy-AI/tree/main](https://github.com/prathamesh-1983/InterviewBuddy-AI/tree/main))

```
interviewbuddy-ai/
│
├── backend/
│   ├── main.py
│   ├── ai.py
│   └── database.py
│
├── frontend/
│   ├── index.html
│   ├── style.css
│   └── app.js
│
├── data/
├── uploads/
├── sample_resume.txt
├── requirements.txt
├── .env.example
├── .gitignore
├── LICENSE
└── README.md
```

InterviewBuddy AI is built around **open-source/open-weight AI running locally** rather than depending on a closed hosted AI API.

The project uses:

The basic AI flow is:

```
Resume
   ↓
Resume text extraction
   ↓
FastAPI backend
   ↓
Personalized prompt
   ↓
Ollama
   ↓
Gemma 3
   ↓
Interview questions
   ↓
Candidate answer
   ↓
Gemma 3 evaluation
   ↓
Feedback + score
   ↓
Final practice report
Frontend
HTML + CSS + JavaScript
        │
        ▼
Backend
Python + FastAPI
        │
        ├──────────────► SQLite
        │
        ▼
Local AI
Ollama + Gemma 3
```

The application accepts:

`.txt`
`.pdf`
`.docx`
The extracted resume content is passed to the AI so that interview

questions can be relevant to the candidate's actual experience and

skills.

For example, a resume mentioning **Excel, Power BI, SQL, Python, and data cleaning** can result in questions specifically related to those

The AI is used for three major tasks:

Open innovation mattered for this project because the application is

intended to be a **personal, repeatable, and privacy-friendly interview practice tool**.

Using a locally running open-weight model made several things possible.

A resume contains personal information such as education, work

experience, contact information, and skills.

With local inference, the core AI processing can happen on the user's

own computer instead of requiring every resume and interview answer to

be sent to a third-party hosted AI service.

```
Traditional hosted approach:

Resume → Internet → Closed AI API → Response

InterviewBuddy:

Resume → Local application → Local Gemma model → Response
```

A local model does not require a paid API request for every practice

question, making repeated interview practice more practical for students

and job seekers.

Because the project communicates with Ollama, the model can be changed

without redesigning the entire application.

```
Gemma 3
   ↓
another compatible local model
```

Running the model locally makes it easier to experiment with prompts,

model choices, response formats, and interview behavior without being

locked into one closed provider.

The project uses technologies that a beginner can inspect, modify, and

learn from:

**DevRelay session:** `[Add your saved DevRelay session link here]`

This section can be updated with the saved DevRelay session so judges

can see the development process.

Building InterviewBuddy AI helped me understand that a useful AI

application does not need to be extremely large.

The most important part was identifying a real problem for one person

and building around that problem.

I also learned how to:

If I continue developing InterviewBuddy AI, I would like to add:

Remove this section if no partner category applies.

Potential partner technologies used in the project:

If entering additional partner categories, list the applicable

categories according to the official challenge requirements.

InterviewBuddy AI started with a simple question:

**What could I build that would genuinely help a friend?**

The answer was not another generic chatbot.

It was a practice partner that could be available whenever they needed

it.

By combining a simple web application with a locally running open-weight

AI model, InterviewBuddy AI makes personalized interview practice more

accessible, repeatable, and privacy-friendly.

**Built for a friend. Built with open AI. Built to be useful.** 🤝