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
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:
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.
Top comments (0)