My Friend Had a Lab Viva Tomorrow. So I Built PracPrep. 🧪

Bhavya Kumar — Mon, 05 Oct 2026 04:56:59 +0000

What I Built

My friend is an engineering student, and like many engineering students, lab preparation often starts at the worst possible time — the night before the practical or viva.

The problem isn't always understanding the experiment itself. The real problem is dealing with a long, messy lab manual and figuring out what actually needs to be prepared: the theory, apparatus, procedure, observations, precautions, and the questions an examiner might ask.

So I built PracPrep — From Lab Manual to Lab-Ready.

PracPrep is an AI-powered lab preparation companion that helps engineering students turn their lab manuals into a structured preparation workflow.

Instead of repeatedly searching through a PDF before a viva, a student can:

Create and organize their experiments.
Upload their lab manual.
Extract the important sections from the document.
Review and edit AI-generated experiment sections before accepting them.
Track preparation using checklists.
Practice viva questions and receive feedback on their answers.
Review previous viva sessions and identify areas that need more preparation.

The goal is simple:

Don't just read the lab manual. Become lab-ready.

I built PracPrep because I wanted the preparation process to feel less like "find the important parts before tomorrow's viva" and more like a structured study workflow.

PracPrep is designed around one idea: turn a lab manual into a preparation workflow.

The Problem

A lab manual can easily become 20, 30, or even more pages of information.

But before a practical or viva, students usually don't need all of it at once.

They need to know:

What is this experiment actually about?
Which theory do I need to understand?
What apparatus should I remember?
What is the correct procedure?
What observations should I expect?
Which precautions are important?
What questions could the examiner ask?

The problem is not a lack of information.

The problem is finding the right information at the right time.

And that is where I wanted PracPrep to help.

┌──────────────────────────────────────┐
│             LAB MANUAL               │
└──────────────────┬───────────────────┘
                   │
          ┌────────┼────────┐
          ↓        ↓        ↓
       Theory  Procedure  Apparatus
          │        │        │
          └────────┼────────┘
                   ↓
        ┌─────────────────────┐
        │    Observations     │
        │    Precautions      │
        │   Viva Questions    │
        └──────────┬──────────┘
                   ↓
          "What do I study?"

Demo

You can try the live version of PracPrep here:

Live Demo: https://prac-prep.vercel.app/

The application is designed around a simple workflow:

Create an experiment → Upload a lab manual → Extract and review experiment sections → Prepare using the checklist → Practice viva questions → Review your performance

For the best experience, try creating an experiment and exploring the experiment workspace.

1. Start with an experiment

A student creates an experiment and enters the basic information needed for preparation.

2. Upload the lab manual

The manual becomes the source material for the preparation workflow.

3. Let AI structure the manual

Instead of blindly trusting the generated output, PracPrep presents the extracted sections for review.

The student can edit the result before accepting it.

                ┌─────────────────┐
                │   Lab Manual    │
                │    PDF / DOCX   │
                └────────┬────────┘
                         ↓
                ┌─────────────────┐
                │ Text Extraction │
                │   + OCR if      │
                │     needed      │
                └────────┬────────┘
                         ↓
                ┌─────────────────┐
                │   AI Section    │
                │     Parser      │
                └────────┬────────┘
                         ↓
                ┌─────────────────┐
                │ Human Review &  │
                │     Editing     │
                └────────┬────────┘
                         ↓
                ┌─────────────────┐
                │ Structured      │
                │ Experiment      │
                └────────┬────────┘
                         ↓
          ┌──────────────┴──────────────┐
          ↓                             ↓
   Preparation Checklist          Viva Practice
          ↓                             ↓
          └──────────────┬──────────────┘
                         ↓
                  Lab-Ready Student

Code

The complete source code for PracPrep is open source and available on GitHub:

GitHub Repository: https://github.com/bhavyaku11/PracPrep

The repository contains the frontend, FastAPI backend, database models, AI provider abstraction, document processing pipeline, authentication, viva system, tests, and deployment configuration.

You can explore the implementation, run PracPrep locally, and see how the different components work together.

How I Built It

PracPrep is built as a modular full-stack application, with the AI layer separated from the rest of the system through a provider abstraction.

The architecture allows different AI providers to be plugged into the same workflows without changing the application logic.

The current implementation includes:

AI provider abstraction — a common interface for question generation, answer evaluation, and document section parsing.
Gemini provider — used for remote AI-powered generation and evaluation.
Deterministic demonstration provider — provides predictable results for development, testing, and fallback scenarios.
Circuit breaker and fallback architecture — prevents repeated provider failures from breaking the application.
Document processing pipeline — extracts text from PDF/DOCX files, uses OCR when required, and then converts the extracted content into structured experiment sections.
Human-in-the-loop review — AI-generated sections are presented to the student for review and editing before being accepted.

The important architectural decision was to keep the AI layer provider-independent. This means PracPrep can integrate an open-weight model or local inference engine without rebuilding the rest of the application.

For this project, I wanted the AI to be a component of a real preparation workflow rather than simply putting a chatbot on top of a lab manual.

                    ┌─────────────────────┐
                    │    React Frontend   │
                    │   Vite + TypeScript │
                    └──────────┬──────────┘
                               │
                         REST API / JWT
                               │
                    ┌──────────▼──────────┐
                    │     FastAPI API     │
                    └──────────┬──────────┘
                               │
          ┌────────────────────┼───────────────────┐
          ↓                    ↓                   ↓
   Document Pipeline      Viva Module        Experiment Module
          │                    │                   │
     PDF / DOCX             AI Provider         PostgreSQL
     Extraction             Abstraction
          │                    │
          ↓              ┌─────┴─────┐
        OCR              ↓           ↓
                    Gemini      Demo Provider

I deliberately separated the AI provider from the application logic so that the rest of PracPrep does not depend on a single model provider.

What Was Actually Hard

Building PracPrep was not just about connecting an AI model to a frontend. Some of the hardest parts were making the system reliable when real-world inputs and failures happen.

1. Messy Lab Manuals

PDFs and DOCX files are not always clean. Some contain structured text, while others are scanned documents or have unusual formatting.

PracPrep therefore uses a document-processing pipeline that can extract digital text and fall back to OCR when necessary.

2. AI Can Fail

AI providers can timeout, return errors, or become temporarily unavailable.

Instead of assuming the AI will always work, I added a provider abstraction, retries, and a circuit-breaker/fallback architecture.

3. AI Output Needs Review

I didn't want AI-generated experiment sections to silently become the student's final content.

PracPrep lets the student review and edit the generated sections before accepting them.

4. Keeping User Data Isolated

Experiments, documents, viva sessions, and study data belong to individual users.

The backend therefore enforces authenticated ownership checks so one user cannot access another user's study data.

5. Testing the Real Database

I also added PostgreSQL integration tests instead of relying only on mocked database behavior.

This helped verify relationships, cascading deletes, transactions, constraints, and guest-data migration against a real PostgreSQL database.

What I Learned

Building PracPrep taught me that the hardest part of an AI product isn't calling an AI model.

It's designing everything around the model.

I learned that:

AI output needs validation.
Real documents are much messier than expected.
Human review is important when AI modifies structured information.
AI failures need to be treated as normal engineering cases.
A useful AI product is a workflow, not just a chatbot.

The biggest lesson for me was simple:

The AI is only one part of the product. The workflow around it is what makes it useful.

What's Next

PracPrep is still evolving.

The next improvements I want to work on include:

More capable local and open-weight AI models.
Better handling of complex and scanned lab manuals.
More realistic viva simulations.
Smarter identification of weak topics.
More personalized revision recommendations.
Better offline and privacy-focused AI workflows.

The long-term goal is to make PracPrep useful across different engineering branches and different types of practical examinations.

Why Does Open Innovation Matter?

For PracPrep, open innovation matters because the AI layer should not be locked to a single provider.

A lab-preparation tool deals with personal study material, including lab manuals, experiment notes, and preparation history. Having a provider-independent architecture makes it possible to choose where and how AI inference happens.

PracPrep therefore separates the AI layer from the rest of the application through an AI provider abstraction.

This makes the system flexible enough to support:

Remote AI providers when students need convenient cloud-based inference.
Open-weight models and local inference when privacy, cost, or offline usage becomes more important.
Different AI models without rewriting the experiment, document-processing, or viva systems.

The key idea is that the student-facing workflow should not depend on one AI provider.

Instead of building a chatbot tightly coupled to a single API, I built PracPrep so that the intelligence layer can evolve independently.

That gives the project a path toward more private, accessible, and customizable AI-assisted learning.

From Lab Manual to Lab-Ready

PracPrep started with a simple question:

What if preparing for a lab viva didn't mean scrolling through a long PDF the night before?

The result is a system that takes the lab manual, structures the experiment, lets the student review it, turns preparation into a checklist, and provides viva practice.

The goal isn't to replace studying.

It's to make studying more focused.

Don't just read the lab manual. Become lab-ready. 🧪

DEV Community: Bhavya Kumar