I Built an Offline AI Interview Coach for My Friend's Job Hunt

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

I Built an Offline AI Interview Coach for My Friend's Job Hunt

Job interviews are stressful enough without having to figure out what to practice, whether an answer is good, and what to improve next.

A friend of mine was preparing for job interviews and had a very familiar problem: they could study technical questions all day, but practicing an actual interview was much harder.

So instead of sending them another list of interview questions, I built them an AI interview coach.

The goal was simple:

Give my friend a private interviewer they can practice with whenever they want.

And because this challenge is about open innovation, I wanted the AI at the center of the project to be something I could actually run, inspect, modify, and experiment with rather than simply sending every conversation to a closed API.

What I Built

I built [PROJECT NAME], a personal AI interview coach designed specifically for [FRIEND'S FIRST NAME / “a friend preparing for software engineering interviews”].

The coach can:

Start a realistic mock interview

Ask technical and behavioral questions

Adapt follow-up questions based on the candidate's answer

Explain what was strong or weak about an answer

Suggest a better structure for answering

Generate additional questions around weak areas

Give a final interview report

Track recurring mistakes across practice sessions

Instead of acting like a chatbot that simply answers questions, the application is designed around one specific workflow:

Interview → Answer → Follow-up → Feedback → Practice → Improve

The most important design decision was that the AI isn't there to do the interview preparation for my friend.

It is there to make my friend practice.

Demo

Live Demo: [ADD YOUR DEPLOYED DEMO LINK]

Demo Video: [ADD YOUR VIDEO LINK]

Here is a typical session:

My friend chooses an interview type.

The AI interviewer asks the first question.

My friend answers without seeing the expected answer.

The AI asks follow-up questions.

The session ends with structured feedback.

The coach identifies areas that should be practiced again.

[ADD 2–4 SCREENSHOTS HERE]

Code

The complete source code is available here:

GitHub: [ADD YOUR GITHUB REPOSITORY LINK]

The repository contains the application code, model configuration, prompts, setup instructions, and the components used to run the interview workflow.

How I Built It

The core of the project uses Gemma, an open-weight model, as the AI engine.

Architecture:

                ┌─────────────────────┐
                │    Web Interface    │
                └──────────┬──────────┘
                           │
                           ▼
                ┌─────────────────────┐
                │ Interview Controller│
                └──────────┬──────────┘
                           │
             ┌─────────────┼─────────────┐
             ▼             ▼             ▼
       Question       Conversation    Evaluation
        Context          Memory          Logic
             │             │             │
             └─────────────┼─────────────┘
                           ▼
                ┌─────────────────────┐
                │   Gemma Model       │
                │   Open-weight AI    │
                └──────────┬──────────┘
                           │
                           ▼
                ┌─────────────────────┐
                │ Feedback + Next     │
                │ Practice Suggestions │
                └─────────────────────┘

The application separates the interview workflow from the model itself.

That means I can experiment with the model, prompts, context, and evaluation logic independently.

For the interview experience, I gave the model a structured role instead of simply asking it to "act like an interviewer."

The model receives information such as:

Interview type

Candidate's previous answers

Current interview stage

Topics being tested

Previous weaknesses

Rules for asking follow-up questions

This makes the interaction much more consistent.

The interesting part

I deliberately didn't make the AI immediately reveal the correct answer.

If my friend gives a weak answer, the coach first tries to behave like a real interviewer:

"Can you explain why you chose that approach?"

Only after the interview does it switch into coach mode and explain what could be improved.

That small distinction makes the tool much more useful for actual practice.

Why Does Open Innovation Matter?

This project would have been easy to build using a closed AI API.

But using an open-weight model changed what I could build.

The biggest advantage is control.

The interview conversations can contain personal information, career plans, mistakes, and other things my friend may not want to send to a third-party service.

With an open model, I can design the system around local or self-hosted inference and decide where the data goes.

That gives the project a different privacy model from a typical AI wrapper.

Open models also make experimentation much more interesting.

I can:

Change the model

Change the system behavior

Run inference locally

Experiment with different prompts

Tune the interview workflow

Compare models

Change the evaluation logic

Potentially fine-tune the model for this particular use case

The model is not a black box API sitting behind my application.

It is one of the components I can actually work with.

For a personal tool built for one person, that control matters.

What I Learned

The biggest lesson was that building an AI application isn't primarily about getting the model to produce impressive text.

It is about designing the interaction around the user's actual problem.

My first instinct was to make the AI answer interview questions.

That wasn't what my friend needed.

They needed someone—or something—to ask them questions, challenge their answers, and make them practice.

That changed the entire design.

The most useful AI feature ended up being the simplest one:

asking the right follow-up question.

Building It for One Person Changed the Product

Normally, when building a product, it's tempting to think about thousands of users.

This challenge forced me to do the opposite.

I started with one person.

I knew:

what kind of interviews they were preparing for

what topics they struggled with

how they preferred to practice

what kind of feedback they found useful

what made them lose confidence during interviews

That made it much easier to decide what the product should and shouldn't do.

Instead of building another generic AI interview chatbot, I could build something personal.

And that is probably my favorite part of this challenge.

What My Friend Said

After trying the first version, I asked:

"[ADD YOUR FRIEND'S ACTUAL FEEDBACK HERE]"

The feedback led to [ADD THE FEATURE/CHANGE YOU ACTUALLY MADE].

That was an important reminder that the person you're building for should be part of the development loop.

The first version wasn't designed to impress judges.

It was designed to help one person.

Results

After [NUMBER] practice sessions, my friend [ADD YOUR REAL OBSERVATION/RESULT].

For example:

[X] interview sessions completed

[X] recurring weak areas identified

[X] new follow-up questions generated

[X] improvement observed in [specific area]

I’m including these numbers because I wanted to evaluate the project based on whether it actually helped the person I built it for—not just whether the demo looked impressive.

What's Next

There are several things I'd like to add:

Voice-based interviews

Resume-aware questioning

More detailed interview analytics

Role-specific interview modes

Local long-term memory

Model comparison

Personalized practice plans

A fully offline mode

But the core idea will stay the same:

Build the AI around the person, not the other way around.

Prize Categories

I'm submitting this project for:

Hacktoberfest Weekend Challenge: Build for a Friend

Best Use of Gemma

[ONLY ADD OTHER PARTNER CATEGORIES HERE IF YOU ACTUALLY USED THOSE TECHNOLOGIES.]

My Agent Session

[OPTIONAL: ADD YOUR DEVRELAY AGENT SESSION HERE]

I used the agent session to document how the project was built and iterated.

Final Thoughts

This project started with a simple question:

What could I build that would actually help someone I know?

The answer wasn't another general-purpose AI assistant.

It was a small, focused tool designed around one person's problem.

That's what I liked about this challenge.

Open innovation isn't only about making powerful models available.

It's also about giving developers enough control to turn those models into tools that solve very specific problems for real people.

I built this one for a friend.

Now I want to see whether it can help them walk into their next interview a little more prepared.

Built for a friend. Powered by open AI. Built for practice.