SpeakUp

Adarsh Negi — Mon, 05 Oct 2026 02:51:03 +0000

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.

About me !

Adarsh Negi — Sun, 04 Oct 2026 10:10:45 +0000

Hey everyone! 👋

I’m Adarsh, a CSE student from India. I’m currently focused on backend development, Python, DSA, and open source.

I’m starting to explore open source and looking forward to making my first meaningful contributions.

I joined DEV.to to document my learning journey, connect with other developers, and hopefully learn from the amazing community here.

Looking forward to building, contributing, and learning along the way!

DEV Community: Adarsh Negi