# VivaMate — An AI Viva Partner Built for a Friend

anmolchaudhary617-ux — Sat, 03 Oct 2026 22:03:45 +0000

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

What I Built

VivaMate is an AI-powered viva practice platform I built for a friend who has to prepare for technical university vivas.

The problem was simple: studying from notes is one thing, but actually answering questions and getting meaningful feedback is another. Finding someone who is always available to conduct a mock viva is not always practical.

So I built VivaMate to act as an on-demand viva practice partner.

You can:

Upload your study material as a PDF or TXT file
Generate viva questions based on your material
Choose the number and difficulty of questions
Take a one-question-at-a-time mock viva
Submit answers for AI evaluation
Receive a score, feedback, ideal answer, and follow-up question
View a final performance report showing strengths and areas to improve

The goal isn't to replace a professor or a real viva. It's to give a student a way to practice repeatedly before the real thing.

Demo

🌐 Live Demo

VivaMate is deployed with a React/Vite frontend on Vercel and a FastAPI backend on Render.

Flow:

Study Material → Question Generation → Mock Viva → AI Evaluation → Performance Report

Code

The complete source code is available on GitHub:

VivaMate GitHub Repository

How I Built It

VivaMate is built around open-weight AI rather than making a proprietary AI API the core of the application.

The core model is Qwen3 4B.

During local development, I run Qwen3 4B locally through Ollama. This allowed me to develop and test the AI workflow directly on my own machine.

The local architecture is:

React + Vite
↓
FastAPI
↓
AI Service Layer
↓
Ollama
↓
Qwen3 4B

For the deployed version, the same AI service abstraction allows the application to use Hugging Face Inference Providers with Qwen3 4B.

The production architecture is:

Vercel
↓
React + Vite
↓
Render
↓
FastAPI
↓
AI Service Layer
↓
Hugging Face Inference Providers
↓
Qwen3 4B

I deliberately kept the AI integration behind a service abstraction so the application isn't tightly coupled to a single model or inference implementation.

The main technologies are:

React + Vite
FastAPI
Python
Ollama
Qwen3 4B
Hugging Face Inference Providers
Pydantic
PyPDF
HTML/CSS/JavaScript

The AI is used for two important parts of the application:

1. Viva Question Generation

Given a topic or uploaded study material, Qwen3 generates structured viva questions with difficulty levels.

When study material is provided, the generated questions are instructed to stay grounded primarily in that material.

2. Answer Evaluation

After the student answers a question, Qwen3 evaluates the response and returns:

Score out of 10
Correctness level
Educational feedback
Ideal answer
Follow-up question

The application doesn't expose the model's internal reasoning. It only uses the structured evaluation needed by the student.

What the Experience Looks Like

VivaMate is designed around a simple practice loop:

Upload → Generate → Answer → Evaluate → Improve

The student answers each question one at a time and receives structured feedback from Qwen3 4B, including a score, correctness assessment, ideal answer, and a follow-up question.

At the end of the session, VivaMate summarizes performance and highlights areas that need further practice.

Why Does Open Innovation Matter?

For VivaMate, open innovation isn't just a technology choice. It changes what the project can be.

Because Qwen3 4B can run locally through Ollama, I could build and test the complete AI workflow on my own machine without making a proprietary cloud AI API a mandatory part of the development setup.

That matters for a study tool because uploaded material can contain personal notes, assignments, or course content.

With local inference, the development version can process the AI requests on the student's own machine rather than requiring every request to be sent to a proprietary AI service.

Open-weight models also give the project flexibility.

VivaMate's AI service is separated from the rest of the application, so the model or inference provider can be changed without rewriting the entire viva system.

For me, the biggest difference was that I wasn't simply building a UI around someone else's AI API. I was able to build the actual learning workflow around an AI model that I could run and experiment with locally.

My Agent Session

I used Google Antigravity as a coding agent while building VivaMate.

The agent helped me implement and verify the React frontend, FastAPI backend, AI integration, document extraction, structured AI responses, mock viva flow, and performance report.

I did not use a DevRelay agent-session link for this submission.

Built for a Friend ❤️

VivaMate started with a simple idea:

Instead of telling my friend to "practice more," why not build them something they can actually practice with?

That became VivaMate.

DEV Community: anmolchaudhary617-ux