An AI-powered full-stack interview preparation platform that analyzes a candidate's resume, self-description, and target job description to generate personalized interview reports, skill gap analysis, technical questions, behavioral questions, and a structured preparation roadmap.
- Project Overview
- Why This Project?
- Key Features
- System Architecture
- Application Workflow
- Project Structure
- Technologies Used
- API Documentation
- Getting Started
- Environment Variables
- Application Screenshots
- Project Documentation
- Challenges Faced
- Testing
- Deployment
- Future Improvements
- Learning Outcomes
- Contributing
- License
Interview Preparation Assistant is a full-stack AI application that helps software developers prepare for interviews more effectively.
Instead of simply generating random interview questions, the application analyzes the candidate's resume, self-description, and the target job description to create a personalized interview preparation report.
The generated report includes:
- Match score
- Resume analysis
- Technical interview questions
- Behavioral interview questions
- Skill gap analysis
- Seven-day preparation roadmap
- AI-generated professional resume
- Downloadable PDF resume
The project demonstrates practical implementation of modern MERN stack development while integrating Generative AI into a real-world workflow.
You can explore the application using the live demo below.
🔗 Live Demo: Wait let me compleat the documentation
If you don't have an account yet:
- Open the Register page.
- Create a new account using your username, email, and password.
- Log in with your newly created credentials.
- Start generating personalized interview reports.
Already have an account?
- Go to the Login page.
- Enter your registered email and password.
- Access your dashboard and continue your interview preparation.
Note: If the demo is hosted on a free-tier service (e.g., Render), the backend may take 30–60 seconds to wake up after a period of inactivity.
Preparing for technical interviews often requires candidates to search through multiple resources, identify missing skills, and manually prepare resumes.
This project automates that process by combining:
- Resume Parsing
- Artificial Intelligence
- Authentication
- File Uploads
- PDF Generation
- MongoDB Data Storage
- React Frontend
- REST APIs
The goal is to provide an intelligent assistant that generates a complete interview preparation plan in just a few seconds.
- User Registration
- User Login
- Secure JWT Authentication
- Cookie-Based Authentication
- Protected Routes
- Logout Functionality
- Resume Analysis
- Job Description Analysis
- Self Description Analysis
- Match Score Generation
- Technical Question Generation
- Behavioral Question Generation
- Skill Gap Identification
- Seven-Day Preparation Plan
- AI Resume Generation
- PDF Upload
- Resume Parsing
- Resume Optimization
- Resume Generation
- Resume PDF Download
- Personalized Interview Report
- Recent Reports History
- Report Storage
- Individual Report Page
- Resume Generation
- Match Score Display
+-------------------------+
| React Frontend |
| (Vite + React) |
+------------+------------+
|
Axios API
|
▼
+-------------------------+
| Express Backend |
| Authentication & APIs |
+------------+------------+
|
+--------------------+--------------------+
| |
▼ ▼
+----------------------+ +----------------------+
| Google Gemini AI | | MongoDB |
| AI Report Generator | | Users & Reports DB |
+----------------------+ +----------------------+
|
▼
+-----------------------------+
| AI Interview Report |
| Resume Generation |
| PDF Generation |
+-----------------------------+
User Registration/Login
│
▼
JWT Authentication
│
▼
Upload Resume (PDF)
│
▼
Enter Self Description
│
▼
Paste Job Description
│
▼
Backend Extracts Resume Text
│
▼
Google Gemini AI Processing
│
▼
Generate Interview Report
│
▼
Validate AI Response (Zod)
│
▼
Store Report in MongoDB
│
▼
Display Report
│
▼
Generate Resume PDF
Interview Preparation Assistant
├── Backend
│ ├── src
│ │ ├── config
│ │ ├── controllers
│ │ ├── middlewares
│ │ ├── routes
│ │ ├── services
│ │ └── models
│ │
│ ├── server.js
│ ├── package.json
│ └── .env
│
├── Frontend
│ ├── public
│ ├── src
│ │ ├── features
│ │ ├── style
│ │ ├── App.jsx
│ │ ├── main.jsx
│ │ └── app.routes.jsx
│ │
│ ├── package.json
│ └── vite.config.js
│
└── README.md
- Node.js
- Express.js
- MongoDB
- Mongoose
- JWT
- bcryptjs
- multer
- cors
- dotenv
- pdf-parse
- Puppeteer
- Google Gemini AI
- Zod
- zod-to-json-schema
- React
- Vite
- React Router DOM
- Axios
- Sass
- Lucide React
- Context API
- VS Code
- Postman
- MongoDB Compass
- Git
- GitHub
- npm
The application follows a layered backend architecture to improve maintainability and scalability.
Routes
│
Controllers
│
Services
│
Database / AI
This separation of concerns makes the project easier to test, extend, and maintain as new features are added.
The backend exposes RESTful APIs for authentication, interview report generation, and resume generation.
| Method | Endpoint | Description | Authentication |
|---|---|---|---|
| POST | /api/auth/register |
Register a new user | ❌ |
| POST | /api/auth/login |
Login an existing user | ❌ |
| GET | /api/auth/logout |
Logout current user | ✅ |
| GET | /api/auth/get-me |
Get logged-in user profile | ✅ |
POST /api/auth/register{
"username":"John Doe",
"email":"john@example.com",
"password":"12345678"
}{
"success": true,
"message": "User registered successfully."
}POST /api/auth/login{
"email":"john@example.com",
"password":"12345678"
}{
"success": true,
"token":"JWT_TOKEN"
}| Method | Endpoint | Description | Authentication |
|---|---|---|---|
| POST | /api/interview |
Generate Interview Report | ✅ |
| GET | /api/interview/report/:interviewId |
Get Single Interview Report | ✅ |
| GET | /api/interview/reports |
Get All Reports | ✅ |
| POST | /api/interview/resume/pdf/:interviewReportId |
Generate Resume PDF | ✅ |
POST /api/interview| Key | Type |
|---|---|
| resume | PDF File |
| selfDescription | Text |
| jobDescription | Text |
resume: resume.pdf
selfDescription:
"I am a MERN Stack developer passionate about building scalable web applications."
jobDescription:
"Looking for a React developer with Node.js experience."
{
"matchScore": 86,
"technicalQuestions": [
{
"question":"Explain React Virtual DOM.",
"answer":"..."
}
],
"behaviorQuestions":[
{
"question":"Tell me about yourself."
}
],
"skillGaps":[
"TypeScript",
"Testing"
],
"preparationPlan":[
"...7 Day Roadmap..."
]
}POST /api/interview/resume/pdf/:interviewReportIdThis endpoint generates a professionally formatted PDF resume based on the AI-generated resume content.
Before running the project, ensure the following software is installed.
- Node.js (v22 or later)
- npm
- MongoDB Atlas or Local MongoDB
- Git
- Google Gemini API Key
git clone https://github.com/yourusername/interview-preparation-assistant.gitcd interview-preparation-assistantMove into the backend directory.
cd BackendInstall dependencies.
npm installStart development server.
npm run devBackend runs on
http://localhost:3000
Move into frontend folder.
cd FrontendInstall dependencies.
npm installRun development server.
npm run devFrontend runs on
http://localhost:5173
Create a .env file inside the Backend directory.
PORT=3000
MONGO_URI=your_mongodb_connection_string
JWT_SECRET=your_secret_key
GOOGLE_GEN_API_KEY=your_google_api_keynpm install express mongoose cors dotenv bcryptjs jsonwebtoken cookie-parser multer pdf-parse puppeteer @google/genai zod zod-to-json-schemanpm install react react-router-dom axios sass lucide-reactOpen two terminals.
cd Backend
npm run devcd Frontend
npm run devOpen your browser.
http://localhost:5173
Replace the following images with actual screenshots after deployment.
The following section provides a detailed explanation of every important file and directory used throughout the project.
Each file has been documented to make it easier for developers to understand the overall architecture, responsibilities, and implementation details.
This documentation is intended for:
- Developers exploring the project.
- Recruiters reviewing project quality.
- Interviewers evaluating architecture decisions.
- Contributors interested in extending the application.
This section provides an overview of the major files and folders in the project. Understanding the responsibility of each file makes it easier to navigate, maintain, and extend the application.
Stores environment variables used by the backend.
Variables include:
- MongoDB Connection URI
- JWT Secret Key
- Google Gemini API Key
- Server Port
This file should never be committed to source control.
Contains backend project information including:
- Project metadata
- Installed dependencies
- Development dependencies
- npm scripts
Main scripts:
npm run dev
npm startThe entry point of the backend application.
Responsibilities:
- Loads environment variables
- Connects MongoDB
- Starts Express Server
- Handles server initialization
Configures the Express application.
Includes:
- Middleware Registration
- Cookie Parser
- CORS Configuration
- Route Registration
- JSON Parsing
Responsible for establishing a connection with MongoDB using Mongoose.
Features:
- Database Connection
- Error Handling
- Connection Status Logging
Defines the User schema.
Stores:
- Username
- Password
- Created Date
Stores every generated interview report.
Contains:
- Job Description
- Resume Content
- Self Description
- Match Score
- Technical Questions
- Behavioral Questions
- Skill Gap Analysis
- Preparation Plan
- Resume HTML
- User Reference
Stores invalid JWT tokens after logout.
Used for:
- Secure Logout
- Token Invalidation
- Session Management
Handles user authentication.
Responsibilities:
- Register User
- Login User
- Logout User
- Get Current User
Handles all interview-related operations.
Responsibilities:
- Generate Interview Report
- Upload Resume
- Parse PDF
- Save Report
- Fetch Reports
- Generate Resume PDF
Protects private routes.
Functions:
- Verify JWT
- Authenticate User
- Reject Invalid Tokens
Handles file uploads.
Uses:
- Multer
- Memory Storage
- File Size Validation
Defines authentication endpoints.
Routes include:
- Register
- Login
- Logout
- Get Current User
Defines interview APIs.
Routes include:
- Generate Report
- Fetch Reports
- Fetch Single Report
- Generate Resume PDF
The core AI engine of the application.
Responsibilities:
- Prompt Engineering
- Google Gemini Integration
- AI Report Generation
- Resume Generation
- Response Validation
- HTML Resume Creation
- PDF Generation
Contains sample data used during development for testing prompts and AI responses.
Contains frontend dependencies and npm scripts.
Main scripts:
npm run dev
npm run buildFrontend entry point.
Responsibilities:
- Render React Application
- Import Global Styles
- Initialize Root Component
Main application component.
Responsibilities:
- Load Context Providers
- Render Application Routes
- Manage Global Layout
Defines client-side routing using React Router.
Routes include:
- Login
- Register
- Home
- Interview Report
Manages global authentication state.
Responsibilities:
- Store User
- Login
- Register
- Logout
- Authentication Status
Custom React Hook for authentication.
Provides:
- Login Function
- Register Function
- Logout Function
- Current User
Communicates with backend authentication APIs using Axios.
Protects authenticated pages.
Features:
- Route Protection
- Redirect Unauthenticated Users
- Loading State
Stores interview-related state.
Responsibilities:
- Current Report
- Reports List
- Loading State
- API Calls
Custom hook for interview operations.
Provides:
- Create Report
- Get Reports
- Get Single Report
- Download Resume
Handles interview API communication with Axios.
Main dashboard page.
Features:
- Upload Resume
- Enter Job Description
- Enter Self Description
- Generate Interview Report
- View Recent Reports
Displays the generated interview report.
Sections include:
- Match Score
- Technical Questions
- Behavioral Questions
- Skill Gaps
- Preparation Plan
- Resume Generator
The project uses SCSS for styling.
Styles are organized into:
- Global Styles
- Authentication Styles
- Home Page Styles
- Interview Page Styles
- Skeleton Loading UI
- Button Components
Stores static assets such as:
- Application Icon
- Images
- Future Static Files
This project follows several software engineering principles:
- Separation of Concerns
- Component-Based Architecture
- Reusable React Components
- RESTful API Design
- Layered Backend Architecture
- Context-Based State Management
-
- Skeleton Loading UI
- Scalable Folder Structure
- Clean Code Practices
Frontend
│
Axios Requests
│
Express Routes
│
Controllers
│
Services
│
Google Gemini AI
│
MongoDB Database
│
Response
│
React UI
Developing this project involved solving several real-world engineering challenges across both the frontend and backend.
- Implemented secure JWT authentication using HTTP-only cookies.
- Protected private routes on both the client and server.
- Managed user sessions and logout functionality.
- Accepted PDF resume uploads using Multer.
- Extracted readable text from uploaded resumes using
pdf-parse. - Validated uploaded files and handled parsing errors gracefully.
- Integrated Google Gemini AI for intelligent interview report generation.
- Designed structured prompts for consistent AI responses.
- Handled AI response validation using Zod schemas.
- Managed API failures, malformed responses, and retry logic.
- Generated professional HTML resumes.
- Converted generated HTML into downloadable PDF documents using Puppeteer.
- Managing authentication state with React Context.
- Handling protected routes.
- Managing asynchronous API requests.
- Building reusable components.
- Organizing a scalable folder structure.
- Designing RESTful APIs.
- Database schema design.
- Error handling.
- Middleware organization.
- Cookie authentication.
- AI service abstraction.
The application has been manually tested across multiple workflows.
- User Registration
- User Login
- Logout
- Protected Routes
- Invalid Credentials
- Authentication Persistence