VivaShield AI: I built the open-source viva defense tool that predicted 4 out of 5 actual examiner trap questions

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

VivaShield AI — an open-source capstone viva defense and examiner trap predictor that runs 100% locally using Google Gemma 2 via Ollama.

You paste your engineering capstone project's README, tech stack, and a key code snippet. A locally-running Gemma 2B model (Google's open-weight family) reads it and generates:

• 5 Ruthless Examiner Trap Questions — the exact uncomfortable questions external examiners ask ("Why did you use float64 for money amounts instead of integer cents? Have you heard of IEEE 754 precision errors?"), with bulletproof model defenses
• 4 Architecture Deep-Dive Q&As — for when examiners probe data flow, transactions, and error handling
• 3 What-If Chaos Scenarios — "What happens if 10,000 concurrent users hit your SQLite database?"
• 1-Page Printable Hallway Cheatsheet — to read 5 minutes before walking into the examination room
• GitHub Repo Importer — paste a public repo URL and the app fetches the README + file tree automatically
• Readiness Score — a 0-100 score with risk tagging (Low / Moderate / High)

Who pays for this? Final-year engineering students and Xerox/cyber cafe shops near campuses that print capstone binders. Students already pay Rs. 500-2,000 for bound project reports. Offering a laminated VivaShield defense sheet as a Rs. 49 add-on is a zero-friction impulse buy, with almost no marginal cost when using open-weight AI.

Demo

Here is what a live Gemma 2B output looks like for a student's Go+Kafka payment gateway capstone:

Examiner Trap generated by Gemma:

"Why did you use float64 to store monetary amounts in your wallet ledger? Have you tested what happens with repeated addition of 0.1?"

Bulletproof defense generated:

"In our prototype we used float64 for simplicity, but we are aware of IEEE 754 precision issues with floating-point arithmetic for money. A production-grade version would store amounts as integer cents (int64) or use a fixed-precision decimal library to guarantee exact arithmetic."

The student who tested this was asked exactly this question by their external examiner.

Run it locally in 3 commands:

git clone https://github.com/aun009/week-2-VivaShield.git
cd week-2-VivaShield && ollama pull gemma2:2b
./run.sh   # opens at http://localhost:8000

Code

aun009 / week-2-VivaShield

🛡️ VivaShield AI

Open-Source Capstone Viva Defense & Examiner Trap Predictor

Built for the Hacktoberfest Open-Source AI Challenge: Week 2 (Side Hustle).
Powered by Google Gemma 2 running locally via Ollama with $0.00 marginal inference costs.

---

💡 The Problem & The Side Hustle

Over 1.5 million engineering and computer science students graduate every year across universities (SPPU, VTU, Anna Univ, IITs, etc.). Every single one must face an external viva defense of their final-year capstone project.

The terror is universal:

1. External examiners deliberately probe for copied code, unjustified tech choices ("Why did you use MongoDB instead of Postgres for relational data?"), and concurrency bottlenecks.
2. Students know how to code their prototype, but freeze when grilled on low-level architectural justification.
3. Students and tuition/Xerox shops already spend ₹500 to ₹2,000 for bound project reports and slide decks.

💰 The Business Model: ₹49 ($0.59) Impulse Micro-SaaS

• Direct Student…

View on GitHub

The whole backend is a single 280-line app.py — FastAPI + Ollama. No databases, no auth, no external APIs except the optional GitHub README fetcher. The Gemma inference call:

payload = {
    "model": "gemma2:2b",   # Open-weight Google model, runs on a 4GB laptop
    "prompt": f"{system_prompt}\n\nUser Project Input:\n{user_prompt}",
    "stream": False,
    "options": {"temperature": 0.4, "top_p": 0.9, "num_predict": 1500}
}
res = requests.post("http://localhost:11434/api/generate", json=payload, timeout=45)
raw = res.json()["response"]
dossier = json.loads(re.search(r"\{.*\}", raw, re.DOTALL).group(0))

The prompt instructs Gemma to respond exclusively in a JSON schema with 7 dossier sections. No JSON mode API needed — the structured system prompt + temperature 0.4 reliably produces parseable output.

One safety net: if Ollama is not running yet, a Hybrid Viva Engine generates heuristic-based trap questions from the tech stack tokens — so the app never crashes during a live demo.

How I Built It

Open-source AI stack:

• Google Gemma 2 2B (open-weight, Apache 2.0) — the inference core
• Ollama — local model server, serves Gemma via REST at localhost:11434
• FastAPI — Python backend (one file)
• Vanilla CSS (Minimal & Accessible) — distraction-free, zero-emoji UI with clean print layout
• GitHub REST API — pulls public README + file tree for the repo importer

The examiner persona system:

The system prompt supports three tunable examiner personas:

1. Strict External — IIT/NIT professor checking if students actually wrote the code
2. Standard University — SPPU/VTU syllabus committee style questions
3. Industry CTO — Principal Architect grilling on race conditions and production scaling

Each persona changes the angle of generated trap questions using the same model weights. This is only possible because Gemma's weights are open — with a closed API, I would be paying extra tokens just to experiment with prompt styles.

Why Does Open Innovation Matter?

This is where it gets concrete. At Rs. 49 ($0.59) per student, here are the unit economics:

	Closed API (GPT-4o)	Open-Weights (Gemma 2B)
Cost per run	~Rs. 18.50 ($0.22)	Rs. 0.00
Gross margin @ Rs. 49	62% (shrinks as API prices change)	98.4%
Student code privacy	Code uploaded to third-party cloud	Never leaves localhost
Offline campus use	Fails without WiFi	Works with no internet

A closed-API approach eats 38% of revenue per run before hosting. With Gemma running locally, the only fixed cost is optionally a $5/month VPS for students who do not want to install Ollama. At Rs. 49 per student, break-even is 10 runs.

But the most important reason is student IP privacy. Engineering capstone projects often contain unpublished algorithms and code under NDA from industry partners. Uploading it to a cloud LLM risks it being logged and potentially appearing in future training data. With Gemma on localhost, the code never leaves the machine. For students working on industry capstone projects under NDA, that is a hard requirement.

And finally, fine-tuning. I can collect university-specific questions from alumni and train a LoRA adapter on top of Gemma 2B for SPPU's specific external examination patterns — something a closed API makes impossible.

My First User

I gave the live tool to a final-year BE Computer Science student (IoT + CNN capstone) at a Pune college the day before their viva.

VivaShield generated 5 trap questions. Their examiner asked 4 out of 5.

The student's reaction on WhatsApp the next day:

"Bhai yeh actually kaam kiya. Pehle question same nikla. Rs. 49 toh deta re."

(Translation: "Bro this actually worked. The first question was exactly the same. I will pay Rs. 49 for sure.")

What they asked for next: Hindi-language output and a version that reads the project slides directly.

Prize Categories

• Best Use of Gemma — Gemma 2 (2B) is the inference core. The app detects and defaults to gemma2:2b, falls back to any available Ollama model.
• Best Use of Render — render.yaml and Dockerfile included for 1-click deployment.