🚀 PrepPilot

AI-Powered Interview Preparation Platform

Your co-pilot for cracking software engineering interviews — powered by AI, built for students.

PrepPilot is a full-stack, AI-driven interview preparation ecosystem that combines mock interviews, resume analysis, coding practice, personalized study plans, and deep analytics into one seamless platform — helping students go from "I don't know where to start" to "I'm interview-ready."

🌐 Live Demo · 📦 GitHub Repository · ⚙️ Installation Guide · ⭐ Star this Repo

📚 Table of Contents

🎯 Project Overview
✨ Key Features
🖼️ Screenshots
🛠️ Tech Stack
🏗️ System Architecture
📁 Folder Structure
⚙️ Installation Guide
🔐 Environment Variables
📡 API Overview
🔄 Project Workflow
🚧 Future Improvements
⚡ Performance Optimizations
☁️ Deployment
🤝 Contributing
📄 License
👨‍💻 Author
💬 Support

🎯 Project Overview

Landing a software engineering job is not just about knowing how to code — it's about structured preparation: technical interviews, resume optimization, behavioral rounds, and consistent practice. Most students juggle five different tools (LeetCode for DSA, a resume checker, YouTube for mock interviews, a spreadsheet for tracking progress, and Notion for study plans) with no single source of truth.

PrepPilot solves this fragmentation.

It is a unified, AI-powered platform that brings every stage of interview preparation — from resume review to live mock interviews to coding practice to progress analytics — under one roof, powered by the Google Gemini API for intelligent, human-like feedback.

The Problem

📌 Students prepare in silos — no centralized tracking of technical + interview readiness.
📌 Manual resume review is slow, subjective, and inaccessible to many.
📌 Mock interviews with peers/mentors are hard to schedule and inconsistent in quality.
📌 Generic coding platforms don't map directly to interview-specific, company-specific prep.
📌 Without analytics, students can't tell if they're actually improving.

The Solution

PrepPilot delivers AI-generated mock interviews with real-time evaluation, AI resume analysis with actionable feedback, a curated question bank filtered by company/topic/difficulty, a personalized study roadmap, and rich analytics — all wrapped in a clean, modern, distraction-free UI.

Who Is It For?

Audience	How PrepPilot Helps
🎓 Students & New Grads	Structured prep for their first SDE role with guided roadmaps
💼 Job Switchers	Sharpen interview skills and resume before applying to new companies
🧑‍🏫 Bootcamp Graduates	Bridge the gap between coursework and real interview expectations
🏢 Placement Cells / Colleges	A single platform to track and mentor students at scale

✨ Key Features

🔐 Authentication & Onboarding

Feature	Description
Signup	Secure account creation with validation
Login	JWT-based session authentication
OTP Verification	Email-based OTP for verified account creation
Forgot Password	Self-service password recovery flow
Reset Password	Secure token-based password reset

🏠 Dashboard

Feature	Description
Personalized Dashboard	At-a-glance summary tailored to the logged-in user
Performance Overview	Snapshot of interview scores, resume score, and coding progress
Statistics	Key numbers — interviews taken, questions solved, streaks
Quick Access	One-click navigation to all core modules

🤖 AI Mock Interview

Feature	Description
AI-Generated Questions	Dynamically generated based on domain and difficulty
Domain Selection	Choose from DSA, System Design, HR, Behavioral, and more
Difficulty Selection	Easy / Medium / Hard tiers
Interview Timer	Real-time countdown to simulate interview pressure
AI Answer Evaluation	Gemini-powered scoring and qualitative feedback
AI Interview Report	Detailed breakdown of strengths and improvement areas
Interview History	Access all past interview sessions
Performance Analytics	Track score trends across sessions

📄 Resume Analyzer

Feature	Description
PDF Upload	Drag-and-drop resume upload
AI Resume Analysis	Gemini-powered parsing and evaluation
Resume Score	Quantified score out of 100
Strengths	AI-highlighted strong points
Weaknesses	AI-identified gaps and red flags
Suggestions	Actionable, line-item improvement tips

💻 Coding Practice

Feature	Description
Practice Questions	Curated DSA and problem-solving questions
Topic Filtering	Filter by Arrays, Trees, DP, Graphs, etc.
Difficulty Filtering	Easy / Medium / Hard
Progress Tracking	Mark questions as solved/attempted

🏦 Question Bank

Feature	Description
Company Questions	Real questions tagged by company (FAANG, product-based, etc.)
Topic Filters	Narrow down by subject area
Difficulty Filters	Sort by complexity
Importance Filters	Focus on high-frequency, high-weightage questions
Search	Instant keyword-based question lookup

🗺️ Study Plan

Feature	Description
Personalized Roadmap	AI/rule-based plan tailored to the user's goals
Task Completion	Checklist-driven daily/weekly tasks
Progress Tracking	Visual completion percentage

📈 Progress & Analytics

Feature	Description
Weekly Analytics	Week-over-week performance summary
Monthly Analytics	Long-term trend visualization
Graphs	Visual charts for scores, activity, and consistency
Streak	Daily practice streak tracker
Milestones	Achievement badges for key progress markers

👤 Profile

Feature	Description
Edit Profile	Update personal info and preferences
Achievements	Earned badges and milestones
Statistics	Personal performance summary

🔍 Global Search & Help

Feature	Description
Global Search	Search across interviews, questions, and resources app-wide
FAQ	Common questions answered
About PrepPilot	Platform mission and background
Contact Developer	Direct line to the maintainer

🖼️ Screenshots

A closer look at PrepPilot's core modules — from the landing experience to AI-driven interview reports.

_{🏠 Landing Page}

_{📊 Dashboard}

_{🤖 AI Mock Interview}

_{📄 Resume Analyzer}

_{💻 Coding Practice}

_{🏦 Question Bank}

_{🗺️ Study Plan}

_{📈 Progress & Analytics}

_{👤 Profile}

_{⚙️ Settings}

_{❓ Help Center}

💡 All screenshots live in the /screenshots directory of this repository. GitHub's markdown sanitizer may strip some inline styles (border-radius/shadow) on the rendered repo page — the gallery degrades gracefully to clean, evenly-sized images in that case, and renders fully styled in browsers/editors that preserve inline CSS.

🛠️ Tech Stack

Frontend

Technology	Purpose
React	Component-based UI library
Vite	Lightning-fast build tool and dev server
React Router	Client-side routing and navigation
Axios	Promise-based HTTP client for API calls
Tailwind CSS	Utility-first CSS framework for rapid styling

Backend

Technology	Purpose
Node.js	JavaScript runtime for the server
Express.js	Minimal and flexible web framework
JWT Authentication	Stateless, secure user session management

Database

Technology	Purpose
MongoDB Atlas	Cloud-hosted NoSQL database
Mongoose	Elegant ODM for MongoDB and Node.js

AI

Technology	Purpose
Google Gemini API	Powers mock interview generation, evaluation, and resume analysis

Deployment

Technology	Purpose
Vercel	Frontend hosting with CI/CD
Render	Backend hosting and API deployment

🏗️ System Architecture

PrepPilot follows a clean client–server–AI architecture. The React frontend communicates with the Express backend via REST APIs, the backend persists data in MongoDB Atlas, and delegates all intelligence tasks (question generation, evaluation, resume analysis) to the Google Gemini API.

graph TD
    A[👤 User] --> B[React + Vite Frontend]
    B -->|Axios / REST API calls| C[Express.js Backend]
    C -->|JWT Auth Middleware| D{Protected Routes}
    D --> E[Mongoose ODM]
    E --> F[(MongoDB Atlas)]
    D --> G[Gemini AI Service Layer]
    G --> H[Google Gemini API]
    H -->|AI Response| G
    G -->|Processed Insights| C
    F -->|Stored / Retrieved Data| E
    C -->|JSON Response| B
    B -->|Rendered UI| A

    subgraph Frontend Layer
    B
    end

    subgraph Backend Layer
    C
    D
    G
    end

    subgraph Data Layer
    E
    F
    end

    subgraph AI Layer
    H
    end

Request Flow

User Interaction — User performs an action (e.g., starts a mock interview) on the React frontend.
API Request — Axios sends an authenticated REST request to the Express backend.
Auth Middleware — JWT middleware validates the token before granting access to protected routes.
Business Logic — Controllers/routes process the request; if AI is required, the request is routed to the Gemini service layer.
AI Processing — The Gemini API generates questions, evaluates answers, or analyzes resumes.
Persistence — Mongoose writes/reads relevant data to/from MongoDB Atlas.
Response — The backend returns a structured JSON response, which the frontend renders in real time.

📁 Folder Structure

PrepPilot/
├── backend/                          # Backend (Node.js + Express)
│   ├── middleware/
│   │   ├── authMiddleware.js
│   │   └── uploadMiddleware.js
│   ├── models/
│   │   ├── interview.js
│   │   ├── question.js
│   │   ├── Resume.js
│   │   ├── StudyPlan.js
│   │   ├── user.js
│   │   ├── userQuestion.js
│   │   └── UserStats.js
│   ├── routes/
│   │   ├── analyticsRoutes.js
│   │   ├── authRoutes.js
│   │   ├── dashboardRoutes.js
│   │   ├── mockInterviewRoutes.js
│   │   ├── questionRoutes.js
│   │   ├── resumeRoutes.js
│   │   ├── searchRoutes.js
│   │   ├── studyPlanRoutes.js
│   │   └── userQuestionRoutes.js
│   ├── services/
│   │   ├── mockInterviewService.js
│   │   └── resumeAnalyzerService.js
│   ├── utils/
│   │   ├── milestoneGenerator.js
│   │   ├── streakUtils.js
│   │   └── timeTracker.js
│   ├── validations/                  # Request/schema validation logic
│   ├── stackQueue.js
│   ├── strings.js
│   ├── trees.js
│   ├── app.js
│   ├── seedQuestions.js
│   ├── server.js
│   ├── testGemini.js
│   ├── .env
│   ├── .gitignore
│   ├── package-lock.json
│   └── package.json
│
├── frontend/                          # Frontend (React + Vite)
│   ├── image/                         # README screenshot assets
│   ├── public/
│   │   ├── favicon.svg
│   │   ├── icons.svg
│   │   └── sample_resume.pdf
│   ├── src/
│   │   ├── api/
│   │   │   └── axios.js
│   │   ├── assets/
│   │   │   └── hero.png
│   │   ├── components/
│   │   │   ├── AppLayout.jsx
│   │   │   ├── AuthCard.jsx
│   │   │   ├── AuthInput.jsx
│   │   │   ├── AuthLayout.jsx
│   │   │   ├── PasswordInput.jsx
│   │   │   ├── ProtectedRoute.jsx
│   │   │   ├── SidebarContext.jsx
│   │   │   └── ThemeToggle.jsx
│   │   ├── context/
│   │   │   ├── AuthContext.jsx
│   │   │   └── UserStatsContext.jsx
│   │   ├── hooks/
│   │   │   └── useTimeTracker.js
│   │   ├── pages/
│   │   │   ├── CodingPractice/
│   │   │   ├── Dashboard/
│   │   │   ├── ForgotPassword/
│   │   │   ├── HelpSupport/
│   │   │   ├── Landing/
│   │   │   ├── Login/
│   │   │   ├── MockInterview/
│   │   │   ├── OtpVerification/
│   │   │   ├── Profile/
│   │   │   ├── Progress/
│   │   │   ├── QuestionBank/
│   │   │   ├── ResetPassword/
│   │   │   ├── ResumeAnalyzer/
│   │   │   ├── Settings/
│   │   │   ├── Singup/
│   │   │   └── StudyPlan/
│   │   ├── services/
│   │   │   ├── analyticsService.js
│   │   │   ├── authService.js
│   │   │   ├── dashboardService.js
│   │   │   ├── milestoneService.js
│   │   │   ├── mockInterviewApi.js
│   │   │   ├── questionService.js
│   │   │   ├── resumeService.js
│   │   │   ├── studyPlanService.js
│   │   │   ├── timeService.js
│   │   │   └── userQuestionService.js
│   │   ├── App.jsx
│   │   ├── index.css
│   │   └── main.jsx
│   ├── .env
│   ├── .eslintrc
│   ├── .gitignore
│   ├── index.html
│   ├── package-lock.json
│   └── package.json
│
├── .gitignore
├── LICENSE
└── README.md

⚙️ Installation Guide

Prerequisites

Node.js v18 or higher
npm or yarn
A MongoDB Atlas account and connection string
A Google Gemini API key

1️⃣ Clone the Repository

git clone https://github.com/adarshsingh31/PrepPilot.git
cd PrepPilot

2️⃣ Backend Setup

cd backend
npm install

Create a .env file inside backend/ (see Environment Variables below), then start the server:

npm run dev

The backend will run on http://localhost:5000 by default.

3️⃣ Frontend Setup

cd frontend
npm install

Create a .env file inside frontend/ (see Environment Variables below), then start the dev server:

npm run dev

The frontend will run on http://localhost:5173 by default.

4️⃣ Run the Full Project Locally

Open two terminal windows:

# Terminal 1 — Backend
cd backend && npm run dev

# Terminal 2 — Frontend
cd frontend && npm run dev

Then visit http://localhost:5173 in your browser. 🎉

🔐 Environment Variables

Backend (`backend/.env`)

Variable	Description
`PORT`	Port on which the Express server runs (e.g., `5000`)
`MONGO_URI`	MongoDB Atlas connection string
`JWT_SECRET`	Secret key used to sign and verify JWT tokens
`JWT_EXPIRES_IN`	Token expiry duration (e.g., `7d`)
`GEMINI_API_KEY`	API key for Google Gemini AI integration
`EMAIL_HOST`	SMTP host used for sending OTP/reset emails
`EMAIL_PORT`	SMTP port
`EMAIL_USER`	SMTP account username/email
`EMAIL_PASS`	SMTP account password/app-password
`CLIENT_URL`	Deployed/local frontend URL, used for CORS and email links

Frontend (`frontend/.env`)

Variable	Description
`VITE_API_BASE_URL`	Base URL of the backend API (e.g., `http://localhost:5000/api`)
`VITE_APP_NAME`	Display name of the application

⚠️ Never commit your .env files. Both are already included in .gitignore.

📡 API Overview

🔑 Authentication APIs

Method	Endpoint	Description
`POST`	`/api/auth/signup`	Register a new user
`POST`	`/api/auth/login`	Authenticate user and issue JWT
`POST`	`/api/auth/send-otp`	Send OTP for email verification
`POST`	`/api/auth/verify-otp`	Verify submitted OTP
`POST`	`/api/auth/forgot-password`	Trigger password reset email
`POST`	`/api/auth/reset-password`	Reset password using token

🤖 Interview APIs

Method	Endpoint	Description
`POST`	`/api/interview/start`	Start a new AI mock interview session
`POST`	`/api/interview/submit-answer`	Submit an answer for AI evaluation
`GET`	`/api/interview/report/:id`	Fetch AI-generated interview report
`GET`	`/api/interview/history`	Get user's past interview sessions

📄 Resume APIs

Method	Endpoint	Description
`POST`	`/api/resume/upload`	Upload resume PDF for analysis
`GET`	`/api/resume/analysis/:id`	Retrieve AI resume analysis result
`GET`	`/api/resume/history`	Get past resume analyses

❓ Question APIs

Method	Endpoint	Description
`GET`	`/api/questions`	Fetch questions with filters (topic, difficulty, company)
`GET`	`/api/questions/:id`	Get a single question's details
`PATCH`	`/api/questions/:id/progress`	Update solved/attempted status

📊 Analytics APIs

Method	Endpoint	Description
`GET`	`/api/analytics/weekly`	Fetch weekly performance analytics
`GET`	`/api/analytics/monthly`	Fetch monthly performance analytics
`GET`	`/api/analytics/streak`	Get current practice streak

🗺️ Study Plan APIs

Method	Endpoint	Description
`GET`	`/api/study-plan`	Fetch user's personalized roadmap
`PATCH`	`/api/study-plan/:taskId/complete`	Mark a study task as complete

🔍 Search APIs

Method	Endpoint	Description
`GET`	`/api/search?q=`	Global search across questions, interviews, and resources

🔄 Project Workflow

Sign Up & Verify — New users register, verify their email via OTP, and log in securely.
Land on Dashboard — Users see a personalized overview of their progress and quick links to every module.
Upload Resume — Users upload their resume for instant AI analysis, scoring, and suggestions.
Take a Mock Interview — Users select a domain and difficulty, take a timed AI-driven interview, and receive a detailed evaluation report.
Practice Coding — Users solve curated problems filtered by topic/difficulty and track completion.
Explore Question Bank — Users prep with company-specific, high-importance questions.
Follow Study Plan — Users follow a personalized roadmap with daily/weekly tasks.
Track Progress — Users monitor weekly/monthly analytics, streaks, and milestones.
Iterate — Users repeat interviews and practice sessions, watching their scores improve over time.

🚧 Future Improvements

🎙️ Voice AI Interviews — Conduct mock interviews via real-time voice interaction
🎥 Video Interviews — Record and analyze body language and delivery
🔐 Google Login — One-click OAuth-based sign-in
🔐 GitHub Login — OAuth sign-in for developers
🏆 Leaderboard — Competitive rankings among peers
🏢 Company-Specific Interview Sets — Tailored mock interviews per target company
🧠 AI Coding Mentor — Real-time hints and code review during practice
📤 Export Reports — Download interview and resume reports as PDF

⚡ Performance Optimizations

Lazy Loading — Route-based code splitting for faster initial page loads
JWT Authentication — Stateless, scalable session management without server-side session storage
REST APIs — Clean, predictable, cacheable API design
Optimized MongoDB Queries — Indexed fields and lean queries to minimize latency
Reusable Components — DRY, modular React components across the frontend
Environment Variables — Configuration separated from code for security and portability

☁️ Deployment

Layer	Platform	Notes
Frontend	Vercel	Auto-deployed from `main` branch with CI/CD
Backend	Render	Node.js web service with auto-restart on push
Database	MongoDB Atlas	Fully managed, cloud-hosted cluster

🔗 Live Application: prep-pilot-beta.vercel.app

🤝 Contributing

Contributions are what make the open-source community such an incredible place to learn and build. Any contributions you make are greatly appreciated.

Fork the repository
Create your feature branch
```
git checkout -b feature/AmazingFeature
```
Commit your changes
```
git commit -m "Add: AmazingFeature"
```
Push to the branch
```
git push origin feature/AmazingFeature
```
Open a Pull Request

Please make sure to update tests and documentation as appropriate.

📄 License

This project is licensed under the MIT License — see the LICENSE file for details.

MIT License

Copyright (c) 2026 Adarsh Singh

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files, to deal in the Software
without restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies of the
Software, subject to the following conditions: the above copyright notice
and this permission notice shall be included in all copies or substantial
portions of the Software.

👨‍💻 Author

Adarsh Singh

💬 Support

If PrepPilot helped you or inspired your own project, please consider:

⭐ Starring this repository to show your support
🐛 Reporting bugs via GitHub Issues
🔀 Contributing new features or improvements
📢 Sharing it with fellow students preparing for interviews

If you found this project useful, don't forget to give it a ⭐!

Built with ❤️ and ☕ by Adarsh Singh

Empowering the next generation of software engineers, one mock interview at a time.

Name		Name	Last commit message	Last commit date
backend		backend
data		data
frontend		frontend
LICENSE		LICENSE
README.md		README.md
wrap_images.py		wrap_images.py

Latest commit

History

Folders and files

Repository files navigation