I Fed 10 Years of Exam Papers to AI and Realized How Badly We Practice

Look at anyone preparing for a big national exam like the UGC-NET, and you’ll see the exact same scene:

They have an 800-page book of past year papers on their desk. They open to a page, stare at a question, their eyes instinctively drift to the bold answer printed two inches below it, and they think: “Yeah, I knew that.”

Then they show up on exam day, stare at a blank screen with a ticking timer, and blank out.

The problem isn't that they didn't study. The problem is that staring at answers in a book isn't practice—it's reading with extra steps.

A few weeks ago, I got fed up looking at these terrible, scanned PDFs and bloated test apps filled with ads and 10-second loading screens. I decided to scrape and clean up 10+ years of past exam papers, dump them into AI, and see what the data actually looked like.

What I found—and what I ended up building—completely changed how I look at test prep.

---

1. What Happens When You Give an LLM 10 Years of Exam Papers?

I gathered thousands of questions across the entire syllabus (teaching aptitude, research methods, reasoning, ICT, literature, etc.), converted the messy OCR scans into clean markdown, and started querying patterns with AI.

Three things immediately jumped out:

1. Examiners are lazy (they just rotate formats)

They don't write new concepts from scratch every year. They take a concept tested in 2019 (say, Qualitative Research types), turn it from a multiple-choice question into a "Match List I with List II" question in 2021, and then turn it into an "Assertion & Reason" pair in 2023.

The underlying concept never changed. Only the coat of paint did.

2. Distractors follow predictable tricks

When examiners write wrong options, they aren't random. They use specific traps over and over:

• Dropping an author from 1850 next to a theory from 1950 because both names sound vaguely familiar.
• Slipping words like "always" or "never" into assertions where reality has exceptions.
• Subtly swapping adjacent terms (like evaluation vs synthesis) hoping you're skimming too fast to notice.

3. We waste time on the wrong 40%

When people self-study, they spend weeks memorizing broad history or theories they already kinda know, while completely skipping the small, high-frequency "free mark" areas—like basic ICT file conversions or fallacy types in Indian logic. The data showed that a few small clusters account for a massive chunk of easy points if you just drill them repeatedly.

---

2. The Real Problem: The Practice Tools Suck

Once I had a clean, parsed dataset of thousands of questions, I asked myself: Why not just dump this into an existing quiz app?

Because every exam app I tested had the same infuriating flaws:

• Way too slow: 4 seconds of spinners between questions while their server logs your click.
• Bloat everywhere: Popups trying to sell you a ₹4,999 coaching subscription.
• Passive flow: You get a question wrong, they show you the answer, and that question disappears forever. You never actually fix the gap in your head.

If you have 10 minutes on a train or between classes, you don't want to log in, navigate three menus, and wait on server latency. You just want to open your phone, blast through 10 quick reps, and get on with your day.

So I built ExamVault (GitHub).

---

3. How I Built It to Work

I didn't want a heavy backend or a database server that costs money to host. I built ExamVault as an offline-first PWA with a simple philosophy: Zero friction. Instant feedback.

Here’s how the loop works:

1. The 10-Minute Commute Drill

The app bundles the entire question bank locally into small JSON shards. When you tap "Start", it loads instantly. No network requests, no loading spinners. You can do a 10-question set on the subway with zero internet connection.

2. Mistakes Don't Disappear (The Mistake Vault)

When you get a question wrong, the app doesn't just show you the green checkmark and move on. It tosses that question into your Mistake Vault.

Those questions stay in your vault, tracking how long it's been since you messed them up, until you deliberately launch a "Mistake Drill" and get them right. If you don't fix your mistakes, they stare you in the face.

3. Unit Health (Visualizing Knowledge Leaks)

Instead of a meaningless aggregate percentage (like "You scored 68%"), the app tracks health across all 20 units individually like health bars in a game:

• Green: You've practiced it recently and accuracy is high.
• Amber: It's been a while; memory decay is starting.
• Red: You're leaking marks here—drill this unit immediately.

4. The Real Exam Screen

Most people get anxious on exam day simply because the government testing interface (NTA CBT) looks like it was designed in 2004 with weird color-coded buttons and split panes. I recreated that exact interface 1:1 inside the app so that sitting for a 3-hour mock feels completely familiar.

---

4. The "Broken Question" Dilemma

When you parse 10 years of OCR question papers, you run into corrupted tables, bad formatting, or disputed answer keys.

I didn't want bad questions disrupting tests. So I built a simple closed loop:

1. Tap a flag icon on any question $\to$ it instantly gets banished from your practice pack so it never shows up again.
2. The report logs silently to a lightweight cloud endpoint.
3. Once I patch the text in the code repo, I hit "Approve" on an admin page.
4. Next time the app is opened, it sees the fix and quietly restores the question to the pool.

Zero friction for the person practicing, clean data for the app.

---

The Takeaway

Building this taught me that for high-stakes exams, the problem usually isn't motivation—it's the friction of the feedback loop.

Reading books feels productive, but it's mostly passive recognition. When you shrink practice down into fast, 10-minute active recall drills that track your mistakes and work offline anywhere, studying stops feeling like a chore you have to sit down for 6 hours to do. It just becomes something you do in the cracks of your day.