StudyMate — Your AI Study Partner for Exam Prep

Kunal Badgujar — Sun, 04 Oct 2026 13:29:49 +0000

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

What I Built

I built StudyMate, an AI study partner designed for a friend who was preparing for engineering finals and struggling with dense technical subjects.

The problem wasn't a lack of study material.

It was knowing what to study, what to practice, and what they actually didn't understand.

StudyMate turns their study material into a complete learning loop:

Notes → Study Guide → AI Quiz → Performance → Weak Topics → Targeted Revision

Instead of simply asking an AI chatbot questions, the student can give StudyMate their own notes and let the system build an exam-focused study session around them.

The experience

Add study material.
Generate an exam-oriented study guide with Gemma.
Take an AI-generated quiz based only on that material.
Get deterministic scoring.
See which topics need more work.
Generate targeted revision for those weak topics.

The goal was simple:

Don't just help my friend study more. Help them study the things they actually need to improve.

Demo

🚀 Live Demo: https://studymate-sable-zeta.vercel.app/

If the hosted AI backend is not available in the deployed demo environment, here's the recorded demo showing the complete working flow:

[Add your demo video link here]

The demo flow is:

Add Material → Generate Study Guide → Generate Quiz → Answer Questions → Identify Weak Topics → Targeted Revision

Code

💻 GitHub: https://github.com/badgujarkunal93-blip/StudyMate

The repository contains the complete frontend, backend, Gemma integration, local storage layer, planning documents, and setup instructions.

How I Built It

The application is built with:

React 19
TypeScript
Vite
Node.js
Express
IndexedDB
localStorage fallback
Google's @google/genai SDK
Gemma 4 — gemma-4-26b-a4b-it

The frontend provides the study experience while the Node/Express backend keeps the AI API credentials away from the browser.

The architecture is:

                    STUDYMATE
                        │
              ┌─────────┴─────────┐
              │                   │
         Study Library        AI Actions
              │                   │
        IndexedDB             Node/Express
              │                   │
              │              @google/genai
              │                   │
              │                Gemma 4
              │                   │
              └─────────┬─────────┘
                        ↓
                Study Guide / Quiz
                        ↓
                 User Performance
                        ↓
                  Weak Topics
                        ↓
                Targeted Revision

Why Gemma?

Gemma is the core AI model behind StudyMate.

I use it for:

Exam-oriented study guide generation
Key concept extraction
Important terminology
AI-generated practice questions
Topic classification
Targeted revision

The quiz itself does not ask an AI model to decide whether the student was correct. Gemma generates the questions and their answer indices, while StudyMate performs the actual scoring deterministically in the browser.

That separation makes the learning loop more predictable.

Why Does Open Innovation Matter?

This was one of the most important decisions in the project.

I didn't want to build another application where the AI layer was just an invisible call to a proprietary chatbot.

The challenge gave me a reason to explore what an open-weight model could make possible.

StudyMate uses Gemma, an open-weight model, as the intelligence behind the core learning workflow.

That matters because the AI isn't just an optional chatbot feature.

It defines how the application works:

Material → Gemma → Learning resources → Quiz → Weakness analysis → Revision

Using an open-weight model also gives the project a much more flexible foundation. The model can be experimented with, swapped, adapted, and integrated into different environments instead of treating the intelligence layer as an untouchable black box.

I also had a practical constraint: my laptop isn't powerful enough to comfortably run a large model locally.

So instead of pretending that local inference was practical, I used hosted Gemma while keeping the student's study library in the browser.

The privacy model is intentionally explicit:

Your study library stays on your device. Material is sent to Gemma only when you request AI assistance.

That was a better fit for the real person I was building for.

What Makes StudyMate Different?

A lot of AI study tools stop here:

Upload notes → Get summary

StudyMate goes further:

YOUR NOTES
    ↓
UNDERSTAND
    ↓
PRACTICE
    ↓
MEASURE
    ↓
FIND WEAKNESS
    ↓
FIX IT

The application doesn't just generate content.

It creates a feedback loop.

If a student repeatedly performs poorly on a topic, that topic becomes part of their weak-topic radar. They can then ask StudyMate to generate focused revision material specifically for that area.

That's the part I wanted my friend to actually use before an exam.

Design

I also wanted StudyMate to feel different from the typical "AI SaaS dashboard."

So I built a retro student app × brutalist UI × modern AI product aesthetic:

Dark charcoal background
Chunky typography
Red accents
Thick borders
Hard offset shadows
Tactile buttons
Responsive mobile navigation

The interface is intentionally bold because studying doesn't need to look like another corporate dashboard.

Building It

I built StudyMate as a completely new project for this challenge.

I used an AI coding workflow with Antigravity and GSD Core to plan and implement the application in phases:

Phase 1: Design system and application shell

Phase 2: Study material management

Phase 3: Real Gemma integration

Phase 4: AI quiz + weak-topic engine

The GSD workflow helped me keep the project focused instead of turning a weekend challenge into an unnecessarily huge application.

The final application has:

Persistent local study materials
Real Gemma API integration
Structured AI responses
Server-side API key protection
Deterministic quiz scoring
Persistent quiz performance
Weak-topic detection
Targeted AI revision
Responsive mobile/desktop UI

A Small Detail I Care About

The application doesn't pretend that everything is AI.

Gemma handles the parts where generative intelligence is useful.

The application handles deterministic logic itself.

For example:

Gemma:

"What questions should this student practice?"

StudyMate:

"Did they actually answer question 4 correctly?"

That separation makes the system more reliable and easier to reason about.

Prize Categories

I'm entering:

🏆 Best Use of Gemma

StudyMate uses Google's Gemma 4 (gemma-4-26b-a4b-it) as the core AI model for study-guide generation, quiz generation, topic classification, and targeted revision.

I am only claiming this category because Gemma is genuinely central to the application's functionality.

Final Thoughts

I started with a very simple problem:

My friend has plenty of notes. They don't have a good way to turn those notes into effective exam preparation.

That became StudyMate.

It isn't trying to replace a teacher.

It isn't trying to be another general-purpose chatbot.

It's a small AI study partner designed around one person's actual workflow:

Understand → Practice → Measure → Improve.

And that's what made this challenge fun for me.

Thanks for checking out StudyMate! 🚀

Live Demo: https://studymate-sable-zeta.vercel.app/

Source: https://github.com/badgujarkunal93-blip/StudyMate

Hacktoberfest #AI #Gemma #React #TypeScript #DEVChallenge

DEV Community: Kunal Badgujar