Building Prep-Pilot, an AI powered personalized Learning Platform

Preparing for NEET is mostly solving questions, checking the answer key, and moving on to the next set. But knowing that you got something wrong isn't the same as knowing why you got it wrong or what you should revise next.

That was the idea behind Prep-Pilot.

What started as a search for a clean NEET question dataset slowly turned into a full-stack platform with AI-powered analysis, automatic flashcard generation, spaced repetition, and a mistake journal. This post is less about the feature list and more about the engineering decisions, trade-offs, and lessons I picked up while building it.

Note: This is still a work in progress, but it's reached a point where real users can start shaping what it becomes.

What is Prep-Pilot?

Prep-Pilot is a NEET preparation platform where students can take mock tests, receive AI-powered feedback on their weak areas, and revise using automatically generated flashcards.

The goal isn't just to tell students their score. It's to help them understand why they lost marks and what they should study next. It's something I wish I had while I was preparing for these competitive exams.

The stack is intentionally simple. No exotic frameworks or unnecessary abstractions, just tools that are well documented, reliable, and easy to maintain.

The Stack

The Question Bank Problem

Before writing the application, I spent far longer than expected looking for a usable NEET dataset.

Some were stemmed beyond recognition.

Some had questions but no answers.

Some had explanations that contradicted the answer key.

Some looked perfect until I realised images or options were missing.

Eventually I combined multiple datasets and built an import pipeline with deduplication, validation and normalization before importing anything into Postgres.

The biggest lesson was simple:

Always validate your data before writing import code.

Using Ollama + Gemma for Metadata

One problem remained.

Some datasets had clean questions but no chapter information, while others had chapter tags but incomplete questions.

Calling an LLM API for thousands of questions would've been expensive, especially since this was essentially a one-time preprocessing task.

Instead, I ran Gemma locally using Ollama and built a small batch pipeline to classify questions into their respective NCERT chapters.

It wasn't perfect, but it performed surprisingly well. More importantly, I could iterate on prompts, rerun classifications, and fix edge cases without worrying about token costs.

Running the model locally turned out to be one of the most practical decisions during development.

Architecture

The application revolves around a fairly straightforward model:

• Users authenticate through Supabase.

• Every completed test creates a test session.

• Responses are stored per question.

• AI analysis is generated once and cached.

• Flashcards accumulate over time instead of being regenerated.

• Incorrect questions automatically populate the mistake journal.

Everything is protected using Supabase Row Level Security so users can only access their own data.

Keeping AI Boring (On Purpose)

I intentionally limited AI usage.

Instead of making an AI request every time a user clicked something, PrepPilot makes just two Gemini calls for an entire test lifecycle.

1. Test Analysis

One request analyzes the complete test, identifies weak chapters, explains recurring mistakes, and generates study suggestions.

The response is cached permanently, so revisiting the analysis never triggers another API call. Caching reduced api calls and token costs significantly.

2. Flashcard Generation

Flashcards are generated only for weak topics that actually need more cards.

If a student already has four Photosynthesis flashcards, Prep-Pilot creates just one more instead of generating five duplicates.

This keeps API usage low while allowing flashcard decks to grow naturally over time.

Spaced Repetition

Flashcards follow a simplified SM-2 scheduling algorithm.

Cards you struggle with appear again sooner.

Cards you consistently remember gradually move further apart.

Scheduling is handled entirely in the database, making due-card calculations reliable across devices and time zones.

Math Rendering

Physics and Chemistry questions rely heavily on equations.

KaTeX renders every mathematical expression across tests, results, flashcards and the mistake journal so formulas remain readable.

What's Live

• 8,000+ questions across Biology, Physics and Chemistry

• Configurable mock tests

• Secure server-side grading

• AI-generated performance analysis

• AI-generated flashcards

• SM-2 spaced repetition

• Mistake journal

• Weekly insights

• Activity heatmap

• Google authentication

• Rate limiting

• Production deployment

What's Next

The biggest focus now isn't adding more AI.

It's improving the learning experience.

Some things on the roadmap:

• Better chapter-level mastery tracking.

• Adaptive question selection based on weak areas.

• Smarter weekly study plans.

• Continued question bank expansion.

Prep-Pilot is still very much a work in progress.

Building it taught me that the hardest part wasn't writing the code, it was finding reliable data, deciding where AI actually adds value, and keeping the overall system simple enough to remain maintainable.

The goal was never to build another mock test platform.

It was to build something that could take a student's mistakes and turn them into a concrete revision plan. Everything else in Prep-Pilot exists to support that idea.