Udaan CAT: Turning 45 Days of CAT Anxiety into a Clear Study Plan

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

What I Built

I built Udaan CAT, a local-first CAT preparation companion for a close friend who has her CAT examination in approximately 45 days.

She was worried—not because she was not willing to work hard, but because the remaining time made every study decision feel urgent. With a large syllabus across VARC, DILR, and QA, she was facing the same questions many aspirants face near the exam:

• What should I study today?
• Which topics are actually weak?
• Am I making progress, or just spending time?
• How do I turn a bad mock or repeated mistake into a better plan?

I wanted to build something more useful than another generic checklist. Udaan CAT turns preparation into a loop:

Assess → Plan → Practice → Measure → Review → Repeat

The application includes:

• An 18-question diagnostic assessment across VARC, DILR, and QA.
• A rules-based 45-day roadmap that prioritizes weak topics.
• Daily six-question drills and section-specific practice sprints.
• Topic-level mastery, accuracy, and skill-delta tracking.
• Automatic error-notebook entries for attempted wrong answers.
• A syllabus tracker and visual mastery heatmap.
• A manual mock-score tracker for external mocks.
• Pomodoro focus sessions linked to daily study segments.
• Formula Vault, CAT calculator, daily briefing, and consistency tracking.
• Optional Firebase authentication and cloud synchronization.
• An optional local AI coach for alternate explanations.

The roadmap is designed as a 45-day preparation system, but for my friend’s situation it works as a compressed 40-day emergency plan. The goal is not to pretend that software can guarantee a percentile. The goal is to make the next useful action obvious and make progress visible.

The most meaningful part happened after I shared it with her. She started using it, became emotional, and told me that her stress had reduced a little because she finally had a plan and could track her progress. The exam did not become easy overnight, but the uncertainty became smaller. For this challenge, that is the outcome I cared about most.

Demo

Source repository

View Udaan CAT on GitHub

Live demo

Live demo: https://drive.google.com/file/d/1LaBvOwWS3hh1-z9Sig61dmMCB7dtxP0e/view?usp=sharing

The project can also be run locally. The core application works without the optional local AI service:

npm install --legacy-peer-deps
npm run dev

Then open http://localhost:3000.

To try the local coach as well:

ollama pull qwen2.5:7b
ollama serve
npm run dev:ai

In another terminal, run npm run dev and use Ask local coach on a completed daily-test question.

Code

The complete source code is available here:

https://github.com/HVbajoria/Udaan-CAT

The main implementation areas are:

• src/App.tsx — Application shell and main screens.
• src/context/AppContext.tsx — Central application state, scoring actions, local persistence, and Firebase synchronization.
• src/components/DailyTestView.tsx — Daily drill selection, question flow, results, skill deltas, and local-coach action.
• src/utils/catScoring.ts — Percentile estimates, mastery thresholds, roadmap generation, daily briefings, and study segments.
• src/services/localCoachService.ts — Typed browser contract for local model explanations.
• server/local-ai-server.mjs — Local Express adapter that validates requests and calls Ollama.
• src/data/ — Static syllabus, diagnostic questions, daily questions, and formulas.

How I Built It

Product architecture

Udaan CAT is a React and TypeScript single-page application built with Vite. AppContext acts as the central state layer for the learner profile, syllabus, diagnostic result, roadmap, daily submissions, mock scores, error log, study sessions, and modal state.

The main user journey is:

Profile setup
    ↓
18-question diagnostic
    ↓
Topic and section analysis
    ↓
45-day roadmap
    ↓
Daily study segments
    ↓
Six-question practice drill
    ↓
Score + mastery update + error logging
    ↓
Mock analysis and next-day prioritization

The scoring and answer-key path is deterministic. Correct answers come from repository data, and the application calculates scores using CAT-style +3 for correct answers, -1 for attempted wrong answers, and 0 for skipped questions. The local model is never allowed to change scores, answer keys, mastery, or roadmap state.

Open-source AI and local inference

For the optional coach, I used:

• Ollama for local model serving.
• qwen2.5:7b as the default open-weight instruct model.
• Express as a small localhost adapter.
• Vite proxying so the browser calls a same-origin /api/coach/explain endpoint.

The browser sends the current question, answer choices, selected answer, verified answer, official explanation, and topic name to the local adapter. The adapter validates the request, builds a constrained prompt, and sends it to Ollama’s /api/chat endpoint.

sequenceDiagram
    actor Student
    participant UI as DailyTestView
    participant Client as localCoachService
    participant Adapter as Express localhost adapter
    participant Model as Ollama + qwen2.5:7b

    Student->>UI: Click Ask local coach
    UI->>Client: Send question context and verified solution
    Client->>Adapter: POST /api/coach/explain
    Adapter->>Adapter: Validate bounded request
    Adapter->>Model: POST /api/chat
    Model-->>Adapter: Supplemental explanation
    Adapter-->>Client: Explanation or graceful error
    Client-->>UI: Render local coach note

The coach is deliberately narrow. It has:

• No cloud API key.
• No database access.
• No tools.
• No ability to mutate scores or learner state.
• No autonomous agent loop.
• A 45-second timeout.
• Bounded request and response sizes.
• Graceful 400, 502, and 503 error handling.

The verified explanation shown by the application remains the source of truth. The model is there to explain the same reasoning in another way when the learner asks for help.

Persistence

The app is local-first:

• Browser progress is saved in localStorage.
• Google-authenticated users can optionally sync profiles, study state, daily submissions, mock scores, session logs, and error logs to Firebase Firestore.
• If Firebase or Ollama is unavailable, the core study workflow can still continue locally.

Why Does Open Innovation Matter?

Open innovation made this project possible in three important ways.

1. Local AI lowered the barrier to building responsibly

I did not need to send my friend’s study questions, selected answers, or preparation context to a hosted AI API. With Ollama, the model can run on the same machine as the application. That gives the learner a more private and inspectable coaching experience.

This also makes the project easier to understand. The inference boundary is visible in the repository, the prompt is auditable, and the model can be changed without rewriting the entire application.

2. Open models make experimentation accessible

A friend-focused project should not require a paid API account, a production cloud deployment, or a complicated infrastructure setup just to try one helpful feature. An open-weight model lets me experiment with:

• Alternate explanation styles.
• Smaller local models for lower-end hardware.
• Different model sizes for speed versus quality.
• Ollama now, with the option to support llama.cpp or another local server later.

3. Open source keeps the important logic deterministic

The project is intentionally not “AI everywhere.” Open innovation helped me add AI where it is useful while keeping the critical educational logic inspectable:

• The repository owns the answer keys.
• The application owns the score calculation.
• The roadmap is rules-based.
• The learner decides whether to ask the coach.
• The model cannot silently rewrite progress.

That balance is important in education. A fluent answer is not automatically a correct answer, and a generated percentile is not an official result.

My Agent Session

I used an agentic coding workflow to inspect the existing application, trace its state and scoring paths, remove the unused hosted-model dependency, introduce a local Ollama adapter, add the Udaan CAT brand identity, and validate the resulting build.

DevRelay session: [Add DevRelay agent session URL or embed here]

Prize Categories

• Open Innovation / Local AI: Udaan CAT uses an open-weight model through local Ollama inference instead of requiring a hosted AI API.
• Build for a Friend: The product was built for a friend who had approximately 40 days left before CAT and needed a calmer, more structured way to prepare.

What I Learned

The biggest lesson was that “helpful” did not mean “add more features.” My friend did not need a complicated AI agent to begin. She needed a clear starting point, a plan that reflected her weak areas, small daily actions, and visible evidence that she was moving forward.

I also learned that emotional impact can be a real product signal. When she became emotional after using the app, it was a reminder that reducing uncertainty can be as valuable as adding functionality. A progress dashboard is not just a collection of cards when it helps someone feel less alone with a difficult goal.

Udaan CAT is still evolving, but it has already done the thing I built it for: it helped my friend replace some of her exam stress with a plan she can actually follow.