Skip to content
BranchesTags

Latest commit

 

History

3 Commits

Folders and files

NameName
Last commit message
Last commit date
backend
backend
 
 
docs
docs
 
 
frontend
frontend
 
 
.gitignore
.gitignore
 
 
LICENSE
LICENSE
 
 
README.md
README.md
 
 

Repository files navigation

CareerForge AI

AI-powered career growth platform for resume analysis, GitHub profile evaluation, job tracking, and mock interview preparation.

The website is live here: 👉 CareerForge AI

📌 Overview

CareerForge AI is a full-stack AI-powered career growth platform built with Next.js App Router.

The platform brings multiple career-development tools into a single dashboard, allowing users to manage and improve different aspects of their career journey.

Users can:

  • Create an account and securely authenticate.
  • Upload and analyze resumes using AI.
  • Get ATS-style resume scoring and improvement suggestions.
  • Analyze GitHub profiles and repositories.
  • Track job applications and their current status.
  • Practice AI-powered mock interviews.
  • Review interview performance and feedback.
  • Manage account and application settings.

The project is designed with a feature-based architecture and follows modern full-stack development practices.

🎯 Vision

The goal of CareerForge AI is to create a single intelligent career platform instead of requiring students and developers to use multiple disconnected tools.

CareerForge AI aims to combine:

  • Resume Intelligence
  • ATS Optimization
  • GitHub Analysis
  • Job Tracking
  • AI Interview Preparation
  • Career Insights
  • Personalized Recommendations

into one scalable SaaS-style application.

✨ Key Features

🔐 Authentication

  • User signup
  • User login
  • Credentials authentication
  • Password hashing using bcryptjs
  • Zod validation
  • Duplicate email prevention
  • Auth.js v5 session management
  • Protected dashboard routes
  • Logout functionality

📄 Resume Analyzer

Users can upload their resume as a PDF and receive AI-powered analysis.

Features include:

  • PDF upload
  • File type validation
  • File size validation
  • Vercel Blob storage
  • PDF text extraction
  • AI-powered resume analysis
  • ATS-style scoring
  • Score breakdown
  • Strength identification
  • Weakness identification
  • Improvement suggestions
  • Persistent resume analysis

🧠 AI Resume Analysis

The resume analysis pipeline uses Google Gemini to analyze extracted resume content.

The system can evaluate areas such as:

  • Resume quality
  • Skills
  • Experience
  • Projects
  • Education
  • Keywords
  • ATS compatibility
  • Areas requiring improvement

The generated structured analysis is normalized before being stored in the database.

🐙 GitHub Analyzer

Users can enter their GitHub username and receive an AI-powered profile analysis.

The system analyzes:

  • GitHub profile
  • Repositories
  • Stars
  • Forks
  • Languages
  • Original repositories
  • Repository activity
  • Technical strengths
  • Missing areas

Gemini then generates structured career-oriented feedback.

💼 Job Tracker

CareerForge AI provides a job application management system.

Users can:

  • Add job applications
  • Edit applications
  • Delete applications
  • Track application status
  • View application statistics

Supported statuses include:

  • Applied
  • Interview
  • Offer
  • Rejected

The dashboard provides derived statistics from the stored job applications.

🤖 AI Mock Interview

Users can practice interviews using AI-generated questions.

Interview flow includes:

  1. Select interview role.
  2. Select difficulty.
  3. Select question count.
  4. Start interview.
  5. Receive AI-generated questions.
  6. Submit answers.
  7. Receive AI evaluation.
  8. View question-level analysis.
  9. Calculate final score.
  10. Store interview history.

⚙️ Settings

The application includes a dedicated settings area where users can manage their account and application preferences.

🛠 Tech Stack

Frontend

Technology Purpose
Next.js 16 Full-stack React framework
React 19 UI development
TypeScript Type safety
Tailwind CSS v4 Styling
shadcn/ui Reusable UI components
React Hook Form Form management
Zod Validation
Lucide React Icons

Backend

Technology Purpose
Next.js Server Actions Server-side business logic
Auth.js v5 Authentication and sessions
Drizzle ORM Database access
PostgreSQL Relational database
Neon PostgreSQL hosting
bcryptjs Password hashing

AI & Processing

Technology Purpose
Google Gemini AI analysis
@google/genai Gemini SDK
unpdf PDF text extraction

Storage

Technology Purpose
Vercel Blob Resume PDF storage

🏗️ Architecture

CareerForge AI follows a modular full-stack architecture built around the Next.js App Router.

%%{init: {"themeVariables": {"fontSize": "12px"}, "flowchart": {"nodeSpacing": 15, "rankSpacing": 20, "padding": 5}}}%%
flowchart TD

    USER[User Browser]

    USER --> NEXT[Next.js 16 App Router]

    NEXT --> MW[Middleware]

    MW --> AUTH_ROUTES[Auth Routes]
    MW --> DASHBOARD[Protected Dashboard]

    AUTH_ROUTES --> AUTH_UI[Login / Signup UI]

    AUTH_UI --> FORM[React Hook Form + Zod]

    FORM --> AUTH_ACTIONS[Authentication Server Actions]

    AUTH_ACTIONS --> AUTH[Auth.js v5]

    AUTH --> DB[(Neon PostgreSQL)]

    DASHBOARD --> UI[Dashboard UI]

    UI --> FEATURES[Feature Modules]

    FEATURES --> SERVER_ACTIONS[Server Actions]

    SERVER_ACTIONS --> DRIZZLE[Drizzle ORM]

    DRIZZLE --> DB

    SERVER_ACTIONS --> BLOB[Vercel Blob]

    SERVER_ACTIONS --> PDF[PDF Extraction]

    PDF --> GEMINI[Google Gemini AI]

    SERVER_ACTIONS --> GITHUB[GitHub REST API]

    GITHUB --> GEMINI

    SERVER_ACTIONS --> GEMINI

    GEMINI --> SERVER_ACTIONS

    SERVER_ACTIONS --> DB

    DB --> UI
Loading

🔄 Complete System Flow

flowchart LR

    USER[User]

    USER --> AUTH[Authentication]

    AUTH --> DASH[Dashboard]

    DASH --> RESUME[Resume Analyzer]
    DASH --> GITHUB[GitHub Analyzer]
    DASH --> JOBS[Job Tracker]
    DASH --> INTERVIEW[AI Interview]
    DASH --> SETTINGS[Settings]

    RESUME --> STORAGE[Vercel Blob]
    RESUME --> PDF[PDF Parser]
    PDF --> AI[Gemini AI]
    AI --> RESUME_DB[(PostgreSQL)]

    GITHUB --> API[GitHub API]
    API --> AI

    GITHUB --> GITHUB_DB[(PostgreSQL)]

    JOBS --> JOB_DB[(PostgreSQL)]

    INTERVIEW --> AI
    INTERVIEW --> INTERVIEW_DB[(PostgreSQL)]

    SETTINGS --> USER_DB[(PostgreSQL)]
Loading

🔐 Authentication Architecture

%%{init: {"themeVariables": {"fontSize": "12px"}, "flowchart": {"nodeSpacing": 15, "rankSpacing": 20, "padding": 5}}}%%
flowchart TD

    LOGIN[Login / Signup]

    LOGIN --> FORM[React Hook Form]

    FORM --> ZOD[Zod Validation]

    ZOD --> ACTION[Server Action]

    ACTION --> DB[(PostgreSQL)]

    DB --> USER_CHECK{User Exists?}

    USER_CHECK -->|No| ERROR[Invalid Credentials]

    USER_CHECK -->|Yes| BCRYPT[bcrypt Password Verification]

    BCRYPT --> PASSWORD{Password Correct?}

    PASSWORD -->|No| ERROR

    PASSWORD -->|Yes| AUTH[Auth.js signIn]

    AUTH --> SESSION[Session Created]

    SESSION --> DASHBOARD[Protected Dashboard]
Loading

📄 Resume Analysis Architecture

%%{init: {"themeVariables": {"fontSize": "12px"}, "flowchart": {"nodeSpacing": 15, "rankSpacing": 20, "padding": 5}}}%%
flowchart TD

    USER[User]

    USER --> UPLOAD[Upload Resume PDF]

    UPLOAD --> VALIDATE[Validate File]

    VALIDATE --> STORAGE[Vercel Blob]

    VALIDATE --> BUFFER[Read PDF Buffer]

    BUFFER --> EXTRACT[Extract Text using unpdf]

    EXTRACT --> GEMINI[Google Gemini]

    GEMINI --> JSON[Structured AI Response]

    JSON --> NORMALIZE[Normalize Analysis]

    NORMALIZE --> DB[(PostgreSQL)]

    DB --> DASHBOARD[Resume Dashboard]

    DASHBOARD --> SCORE[ATS Score]
    DASHBOARD --> STRENGTHS[Strengths]
    DASHBOARD --> WEAKNESSES[Weaknesses]
    DASHBOARD --> SUGGESTIONS[Suggestions]
Loading

🐙 GitHub Analysis Architecture

%%{init: {"themeVariables": {"fontSize": "12px"}, "flowchart": {"nodeSpacing": 15, "rankSpacing": 20, "padding": 5}}}%%
flowchart TD

    USER[User]

    USER --> INPUT[GitHub Username]

    INPUT --> ACTION[GitHub Server Action]

    ACTION --> API[GitHub REST API]

    API --> PROFILE[Profile Data]

    API --> REPOS[Repository Data]

    PROFILE --> AGGREGATE[Aggregate Statistics]

    REPOS --> AGGREGATE

    AGGREGATE --> GEMINI[Google Gemini AI]

    GEMINI --> ANALYSIS[Structured GitHub Analysis]

    ANALYSIS --> DB[(PostgreSQL)]

    DB --> UI[GitHub Dashboard]

    UI --> SCORE[Profile Score]
    UI --> STRENGTHS[Strengths]
    UI --> MISSING[Missing Skills]
    UI --> SUGGESTIONS[Suggestions]
Loading

🤖 AI Interview Architecture

%%{init: {"themeVariables": {"fontSize": "12px"}, "flowchart": {"nodeSpacing": 15, "rankSpacing": 20, "padding": 5}}}%%
flowchart TD

    USER[User]

    USER --> CONFIG[Role + Difficulty + Question Count]

    CONFIG --> CREATE[Create Interview]

    CREATE --> GEMINI[Google Gemini]

    GEMINI --> QUESTIONS[Generate Questions]

    QUESTIONS --> USER_ANSWER[User Answers]

    USER_ANSWER --> EVALUATE[AI Evaluation]

    EVALUATE --> ANALYSIS[Question Analysis]

    ANALYSIS --> SCORE[Score Calculation]

    SCORE --> COMPLETE[Interview Completed]

    COMPLETE --> DB[(PostgreSQL)]

    DB --> HISTORY[Interview History]
Loading

💼 Job Tracker Architecture

%%{init: {"themeVariables": {"fontSize": "12px"}, "flowchart": {"nodeSpacing": 15, "rankSpacing": 20, "padding": 5}}}%%
flowchart TD

    USER[User]

    USER --> JOB_FORM[Job Form]

    JOB_FORM --> VALIDATE[Validation]

    VALIDATE --> ACTION[Server Action]

    ACTION --> DB[(PostgreSQL)]

    DB --> LIST[Job Applications]

    LIST --> STATUS[Application Status]

    STATUS --> APPLIED[Applied]
    STATUS --> INTERVIEW[Interview]
    STATUS --> OFFER[Offer]
    STATUS --> REJECTED[Rejected]

    DB --> STATS[Dashboard Statistics]
Loading

📊 Data Architecture

The main database schema is maintained in:

frontend/db/schema.ts

Main tables include:

users
accounts
sessions
verification_tokens
resumes
jobs
interviews

Relationships

users
 │
 ├── resumes
 │
 ├── jobs
 │
 ├── interviews
 │
 ├── accounts
 │
 └── sessions

The system uses PostgreSQL with Drizzle ORM for type-safe database operations.

📂 Project Structure

careerforge-ai/
│
├── backend/
│   └── Reserved for future dedicated backend service
│
├── docs/
│   └── Documentation assets
│
├── frontend/
│   │
│   ├── app/
│   │   ├── (auth)/
│   │   │   ├── login/
│   │   │   └── signup/
│   │   │
│   │   ├── api/
│   │   │   └── auth/
│   │   │
│   │   ├── dashboard/
│   │   │   ├── github/
│   │   │   ├── interview/
│   │   │   ├── jobs/
│   │   │   ├── resume/
│   │   │   └── settings/
│   │   │
│   │   ├── layout.tsx
│   │   └── page.tsx
│   │
│   ├── ai/
│   │   └── AI client configuration
│   │
│   ├── components/
│   │   └── Shared UI components
│   │
│   ├── config/
│   │   └── Application configuration
│   │
│   ├── constants/
│   │   └── Static constants
│   │
│   ├── db/
│   │   ├── index.ts
│   │   └── schema.ts
│   │
│   ├── drizzle/
│   │   └── Database migrations
│   │
│   ├── features/
│   │   ├── auth/
│   │   ├── resume/
│   │   ├── jobs/
│   │   ├── github/
│   │   ├── interview/
│   │   └── settings/
│   │
│   ├── hooks/
│   │   └── Reusable React hooks
│   │
│   ├── lib/
│   │   ├── auth/
│   │   ├── blob/
│   │   └── pdf/
│   │
│   ├── services/
│   │   └── Service layer utilities
│   │
│   ├── types/
│   │   └── Type definitions
│   │
│   ├── utils/
│   │   └── Shared utilities
│   │
│   ├── emails/
│   │   └── Email templates
│   │
│   ├── middleware.ts
│   ├── package.json
│   └── .env.local
│
└── README.md

🧩 Feature Modules

Authentication

  • Signup
  • Login
  • Credentials authentication
  • Password hashing
  • Session management
  • Logout
  • Protected routes

Dashboard

  • Dashboard overview
  • Navigation sidebar
  • Navbar
  • Profile dropdown
  • Notifications UI
  • Quick access to modules
  • Career statistics

Resume

  • Resume upload
  • PDF validation
  • Vercel Blob storage
  • PDF parsing
  • AI analysis
  • ATS scoring
  • Resume feedback

Jobs

  • Create job application
  • Update job application
  • Delete job application
  • Track status
  • Job statistics

GitHub

  • GitHub profile lookup
  • Repository analysis
  • GitHub statistics
  • AI scoring
  • Strength analysis
  • Missing skill analysis
  • Improvement suggestions

Interview

  • AI-generated questions
  • Role selection
  • Difficulty selection
  • Answer submission
  • AI evaluation
  • Question-level feedback
  • Final score
  • Interview history

Settings

  • User settings
  • Profile management
  • Application preferences

🛣️ Important Routes

/login
/signup

/dashboard
/dashboard/resume
/dashboard/jobs
/dashboard/github
/dashboard/interview
/dashboard/settings

/api/auth/*

🔄 Request Lifecycle

A typical request follows this architecture:

User
  ↓
Next.js App Router
  ↓
Middleware
  ↓
Protected Route
  ↓
Client Component
  ↓
Server Action
  ↓
Validation
  ↓
Business Logic
  ↓
Drizzle ORM / External API / AI
  ↓
PostgreSQL / Blob Storage
  ↓
Server Response
  ↓
UI Update

🛡️ Security

CareerForge AI follows several security-oriented practices:

  • Server-side authentication
  • Protected dashboard routes
  • Password hashing with bcryptjs
  • Zod input validation
  • Server Actions for sensitive operations
  • Environment variables for secrets
  • Database-level persistence
  • File type validation
  • File size validation
  • Authentication session checks

Sensitive API keys and database credentials are never intended to be committed to the repository.

📜 Environment Variables

Create:

frontend/.env.local

Example:

DATABASE_URL="your_postgresql_connection_string"

GEMINI_API_KEY="your_gemini_api_key"

AUTH_SECRET="your_auth_secret"

NEXTAUTH_URL="http://localhost:3000"

BLOB_READ_WRITE_TOKEN="your_vercel_blob_token"

Do not commit .env.local to GitHub.

🚀 Local Development

1. Clone Repository

git clone <repository-url>

2. Enter Project

cd careerforge-ai/frontend

3. Install Dependencies

npm install

4. Configure Environment Variables

Create:

.env.local

and add the required environment variables.

5. Run Database Migration

npm run db:migrate

6. Start Development Server

npm run dev

The application will be available at:

http://localhost:3000

📦 Available Scripts

Run these commands inside the frontend directory.

Command Description
npm run dev Start development server
npm run build Create production build
npm run start Start production server
npm run lint Run ESLint
npm run db:generate Generate Drizzle migrations
npm run db:migrate Apply database migrations
npm run db:studio Open Drizzle Studio

🧠 Learning Goals

This project demonstrates practical knowledge of:

  • Modern Full Stack Development
  • Next.js App Router
  • React
  • TypeScript
  • Tailwind CSS
  • Server Actions
  • Authentication
  • Authorization
  • Database Design
  • PostgreSQL
  • Drizzle ORM
  • API Integration
  • AI Integration
  • File Upload Systems
  • PDF Processing
  • SaaS Architecture
  • Feature-based Architecture
  • Security Best Practices
  • Production Deployment
  • Scalable Application Design

🏆 Why CareerForge AI?

CareerForge AI is designed as more than a simple CRUD project.

It combines:

Authentication
      +
Database
      +
File Storage
      +
PDF Processing
      +
External APIs
      +
Generative AI
      +
Dashboard
      +
Job Tracking
      +
Interview System
      =
Complete Career Platform

The project demonstrates how different full-stack technologies can work together to build a real-world SaaS-style application.

🚀 Future Architecture

The long-term architecture is designed to support additional services:

flowchart TD

    CLIENT[Web Client]

    CLIENT --> NEXT[Next.js Application]

    NEXT --> AUTH[Auth Service]
    NEXT --> API[Application Services]

    API --> DB[(PostgreSQL)]

    API --> STORAGE[Object Storage]

    API --> AI[AI Service]

    API --> GITHUB[GitHub API]

    API --> EMAIL[Email Service]

    API --> PAYMENTS[Payment Service]

    API --> QUEUE[Background Jobs]

    QUEUE --> REPORTS[Reports]

    QUEUE --> EMAIL

    NEXT --> ANALYTICS[Analytics]

    NEXT --> MONITORING[Monitoring]
Loading

This allows CareerForge AI to gradually evolve from a monolithic Next.js application into a more scalable service-oriented architecture when required.

👨‍💻 Author

Avinash Kumar

B.Tech CSE (DSAI)
IIIT Ranchi

Building CareerForge AI 🚀

📄 License

This project is licensed under the terms specified in the LICENSE file.

Built with ❤️ by AVINASH KUMAR using Next.js, TypeScript, PostgreSQL, Drizzle ORM .

About

AI-powered career assistant with resume analysis, ATS scoring, job matching, GitHub insights, AI mock interviews, and personalized learning roadmaps.

careerforge-ai-app-liart.vercel.app

Resources

Readme
License
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages