SpeakUp

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

What I Built

I built SpeakUp, a local AI-powered mock interview coach for my friend Ayan.

Ayan is preparing for placements and has a frustrating problem: he knows the answers, but struggles to communicate them during interviews.

When we discuss technical topics normally, he can explain them well. But when placed in an interview-like situation, he tends to hesitate, use filler words, lose structure, and struggle to communicate his thoughts clearly.

So I built SpeakUp specifically for him.

Instead of simply giving him interview questions and showing the "correct" answer, SpeakUp acts as an interviewer:

Question → Ayan answers → AI evaluates → Follow-up question → Feedback

The system evaluates things such as:

• Clarity
• Relevance
• Answer structure
• Filler-word usage
• Completeness
• Communication quality

It then gives actionable feedback and continues the interview with a follow-up question.

The goal isn't to teach Ayan what to say.

It's to help him communicate what he already knows.

Demo

🌐 Live Demo: [NO DEPLOYED LINK]

Here's a short example of an interview session:

Interviewer: Explain the difference between a process and a thread.

Ayan answers the question.

SpeakUp then analyzes the response and provides feedback such as:

Clarity        7/10
Relevance      9/10
Structure      5/10
Communication  6/10

Filler words:
"um"           × 4
"actually"     × 2

Suggestions:
→ Start with a concise definition.
→ Compare the two concepts explicitly.
→ Finish with a concrete example.

It then asks a follow-up question instead of ending the conversation.

Code

💻 GitHub: [NO GITHUB REPOSITORY]

The project is built with Python and is designed to run locally.

How I Built It

The core of SpeakUp is an open-weight AI model running locally rather than a closed AI API.

The current stack is:

• Python — application logic
• Streamlit — user interface
• Ollama — local model inference
• Gemma — open-weight language model
• Git/GitHub — source control and project distribution

The basic architecture looks like this:

                ┌───────────────────┐
                │    SpeakUp UI     │
                │    Streamlit      │
                └─────────┬─────────┘
                          │
                          ▼
                ┌───────────────────┐
                │ Interview Engine  │
                │     Python        │
                └─────────┬─────────┘
                          │
                          ▼
                ┌───────────────────┐
                │      Ollama       │
                │  Local Inference  │
                └─────────┬─────────┘
                          │
                          ▼
                ┌───────────────────┐
                │      Gemma        │
                │   Open-weight AI  │
                └───────────────────┘

The model generates interview questions, evaluates responses, provides feedback, and generates follow-up questions.

The application is designed around the model rather than using AI as an additional feature.

Why Does Open Innovation Matter?

Interview practice can involve personal information: a student's projects, weaknesses, communication difficulties, career plans, and the answers they give during practice sessions.

I didn't want Ayan's interview practice to depend entirely on sending that information to a closed API.

With a local open-weight model, the core interaction can happen directly on the user's machine.

Closed API

Ayan
  ↓
Application
  ↓
External API
  ↓
Closed model
  ↓
Response


SpeakUp

Ayan
  ↓
SpeakUp
  ↓
Local inference
  ↓
Open-weight model
  ↓
Feedback

Open models also give developers more control.

I can experiment with different models, change prompts and evaluation strategies, run inference locally, and potentially fine-tune the system for interview practice without redesigning the entire application around a proprietary API.

For this particular project, open innovation isn't just about using an open model because the challenge asks for it.

It directly supports the problem I'm trying to solve:

private, controllable, locally-run interview practice.

My Agent Session

I used the session to document the development process and show how the project evolved from the initial idea into the final application.

What Ayan Thought

After building the first version, I gave it to Ayan and asked him to actually use it for a mock interview.

[ADD ACTUAL EXPERIENCE / QUOTE FROM AYAN]

The most interesting part wasn't whether the AI could answer interview questions.

It was whether it could help Ayan answer them better.

That's what I wanted to test.

What I Learned

Building SpeakUp changed how I think about AI projects.

It would have been easy to build another chatbot that asks questions and generates answers.

But the real problem wasn't:

"How can AI answer interview questions?"

It was:

"How can AI help someone communicate knowledge they already have?"

That distinction shaped the entire project.

It also showed me one of the practical advantages of open-weight AI: the model can become part of the application architecture rather than simply being an external API that the application calls.