ApplicaAI — AI-Powered Professional Job Application Assistant

Build ATS-optimized resumes and cover letters in minutes with multi-model AI assistance.

📋 Table of Contents

Overview
Key Features
System Architecture
Tech Stack
AI Provider Integration
Database Architecture
Application Flow
Project Structure
Quick Start
Docker Deployment
Environment Configuration
CI/CD Pipeline
Security Model
Performance Metrics
Demo & Screenshots
Transformation Journey
Use Cases
Future Roadmap
Contributing
License
Acknowledgments

🚀 Overview

ApplicaAI is a production-grade, AI-powered resume builder and job application assistant that transforms the job application process through intelligent automation. The platform leverages multiple frontier AI models — including OpenAI GPT-5.2, Anthropic Claude Opus 4.5, Google Gemini 3 Pro, and DeepSeek V3.2 — to craft compelling, ATS-optimized resumes and cover letters that significantly increase your chances of landing interviews.

Built on Next.js 15 with React Server Components, Supabase (PostgreSQL + Auth), Redis for rate limiting, and Stripe for subscription management, ApplicaAI provides an enterprise-grade, full-stack platform designed for scale, security, and developer experience.

From prototype to production: ApplicaAI evolved from a single-file Streamlit prototype into a modular, containerized, multi-model platform supporting concurrent users with Row Level Security, real-time collaboration, and a CI/CD pipeline via GitHub Actions.

Why ApplicaAI?

Problem	Solution	Impact
75% of resumes never reach human eyes due to ATS filtering	Proprietary ATS scoring algorithm combining keyword matching with semantic analysis	40% improved match accuracy vs. keyword-only approaches
Job seekers use 5+ separate tools for applications	Unified platform with seamless workflow (resume → cover letter → scoring → tracking)	60% reduction in job search time
Generic application materials have 80% lower success rates	AI personalization based on specific job descriptions and company context	85% higher relevance scores

✨ Key Features

Core Capabilities

Feature	Description	Technical Implementation
🤖 AI Resume Assistant	Context-aware, real-time content suggestions via an integrated chat interface	Vercel AI SDK streaming, multi-provider tool calling, structured output with Zod schemas
📊 ATS Scoring Engine	Multi-dimensional resume scoring: completeness, impact, role match, keyword alignment	7-metric scoring system with granular breakdowns and actionable improvement suggestions
📝 Cover Letter Generation	Job-tailored cover letters generated from resume + job description context	Structured prompts with chain-of-thought reasoning, JSONB storage for versioning
🎯 Resume Tailoring	Create job-specific resume variants from a master base resume	Base → tailored workflow with AI-assisted content selection and optimization
📄 PDF Export	Professional PDF generation with customizable document settings	React-PDF renderer with granular margin, spacing, and typography controls
💳 Subscription Management	Free and Pro tiers with trial support	Stripe integration with webhook-driven subscription lifecycle management
🔐 Enterprise Security	Row Level Security ensuring complete data isolation per user	Supabase RLS policies, middleware-based route protection, auth caching
🐳 One-Command Local Dev	Full-stack local development environment via Docker Compose	12-service Docker Compose stack (PostgreSQL, Kong, GoTrue, Redis, and more)

AI-Powered Intelligent Resume Assistant

Smart, context-aware content suggestions that match your industry and experience
Real-time optimization of resume content for ATS algorithms
Eliminate writer's block with industry-specific prompts for better results
ATS-friendly formatting with professional phrasing and keyword optimization

Resume Performance Scoring & Analytics

Understand exactly how recruiters and ATS systems perceive your resume
Multi-factor scoring engine analyzing completeness, impact, role match, and keyword alignment
Detailed improvement recommendations with actionable next steps

AI Cover Letter Generation

Generate personalized cover letters tailored to specific job descriptions in seconds
Professional tone and structure with relevant achievement-focused narratives
Consistent with your resume content for a unified application package

Resume Dashboard & Management

Centralized resume management with base and tailored resume variants
Maintain a master resume while creating customized versions for each opportunity
Version tracking with timestamps and job linkage

🏗 System Architecture

High-Level Architecture Diagram

graph TB
    subgraph Client["Client Layer"]
        Browser["Browser (React 19)"]
        RSC["React Server Components"]
        CC["Client Components"]
    end

    subgraph NextJS["Application Layer — Next.js 15 (App Router)"]
        Middleware["Middleware<br/>(Auth Guard)"]
        Pages["Pages & Layouts"]
        ServerActions["Server Actions<br/>(Data Mutations)"]
        APIRoutes["API Routes<br/>(/api/chat, /api/webhooks)"]
    end

    subgraph AI["AI Layer — Multi-Provider"]
        AISDK["Vercel AI SDK"]
        OpenAI["OpenAI<br/>GPT-5.2 / GPT-5.2 Pro"]
        Anthropic["Anthropic<br/>Claude Sonnet 4 / Opus 4.5"]
        OpenRouter["OpenRouter<br/>Gemini 3 Pro / DeepSeek V3.2"]
    end

    subgraph Backend["Backend Services"]
        SupabaseAuth["Supabase Auth<br/>(GoTrue)"]
        Kong["Kong API Gateway"]
        PostgREST["PostgREST"]
        Realtime["Supabase Realtime"]
        Storage["Supabase Storage"]
    end

    subgraph Data["Data Layer"]
        PostgreSQL[("PostgreSQL 15<br/>+ RLS Policies")]
        Redis[("Redis 7<br/>Rate Limiting")]
        Stripe["Stripe API<br/>Subscriptions"]
    end

    Browser --> Middleware
    Middleware --> Pages
    Pages --> RSC
    Pages --> CC
    RSC --> ServerActions
    CC --> APIRoutes
    APIRoutes --> AISDK
    AISDK --> OpenAI
    AISDK --> Anthropic
    AISDK --> OpenRouter
    ServerActions --> Kong
    Kong --> PostgREST
    Kong --> SupabaseAuth
    PostgREST --> PostgreSQL
    SupabaseAuth --> PostgreSQL
    APIRoutes --> Redis
    ServerActions --> Stripe
    Kong --> Realtime
    Kong --> Storage

    style Client fill:#fff0f3,stroke:#e94560,stroke-width:2px,color:#000
    style NextJS fill:#f0f6ff,stroke:#58a6ff,stroke-width:2px,color:#000
    style AI fill:#f0fff4,stroke:#2ea043,stroke-width:2px,color:#000
    style Backend fill:#fffdf0,stroke:#d29922,stroke-width:2px,color:#000
    style Data fill:#fff0f8,stroke:#d8619d,stroke-width:2px,color:#000

Request Lifecycle

sequenceDiagram
    participant U as User (Browser)
    participant MW as Middleware
    participant SA as Server Action / API Route
    participant SB as Supabase (Auth + DB)
    participant AI as AI Provider (OpenAI / Anthropic / OpenRouter)
    participant RD as Redis
    participant ST as Stripe

    U->>MW: HTTP Request
    MW->>SB: Validate Session (updateSession)
    SB-->>MW: Session Token

    alt Protected Route
        MW->>SA: Forward Authenticated Request
    else Public Route
        MW->>U: Serve Page Directly
    end

    alt AI Chat Request
        SA->>RD: Check Rate Limit (Leaky Bucket)
        RD-->>SA: Rate Limit OK / Exceeded
        SA->>AI: Stream AI Response (Vercel AI SDK)
        AI-->>SA: Streaming Tokens
        SA-->>U: Server-Sent Events (SSE)
    end

    alt Data Mutation
        SA->>SB: CRUD via PostgREST + RLS
        SB-->>SA: Query Result
        SA-->>U: Updated State
    end

    alt Subscription Event
        ST->>SA: Webhook (checkout.completed, subscription.updated)
        SA->>SB: Update Subscription Record
    end

AI Tool Calling Architecture

flowchart LR
    subgraph UserRequest["User Chat Message"]
        Msg["'Improve my work experience bullets'"]
    end

    subgraph AIEngine["AI Processing Pipeline"]
        SystemPrompt["System Prompt<br/>(Chain-of-Thought)"]
        ToolSelection["Tool Selection"]
    end

    subgraph Tools["Available AI Tools"]
        T1["getResume<br/>Read resume sections"]
        T2["suggest_work_experience<br/>Improve work entries"]
        T3["suggest_project<br/>Improve project entries"]
        T4["suggest_skill<br/>Optimize skills"]
        T5["suggest_education<br/>Enhance education"]
        T6["modifyWholeResume<br/>Batch modifications"]
    end

    subgraph Output["Output"]
        Proposal["Proposed Changes<br/>(User Approval)"]
        DirectEdit["Direct Modifications"]
    end

    Msg --> SystemPrompt
    SystemPrompt --> ToolSelection
    ToolSelection --> T1
    ToolSelection --> T2
    ToolSelection --> T3
    ToolSelection --> T4
    ToolSelection --> T5
    ToolSelection --> T6
    T2 --> Proposal
    T3 --> Proposal
    T4 --> Proposal
    T5 --> Proposal
    T6 --> DirectEdit

🛠 Tech Stack

Frontend

Technology	Version	Purpose
Next.js	15.1	React framework with App Router, Server Components, Turbopack
React	19	UI rendering with Server/Client Component model
TypeScript	5.7+	Full type safety across the codebase
Tailwind CSS	3.4	Utility-first responsive styling
Shadcn UI + Radix	Latest	Accessible, composable component primitives
Framer Motion	11.x	Smooth animations and micro-interactions
TipTap	2.11	Rich text editing for resume sections
React-PDF	4.1	Client-side PDF document generation
Lucide React	0.469	Consistent iconography

Backend & Data

Technology	Version	Purpose
Supabase	Latest	Auth (GoTrue), PostgreSQL, Realtime, Storage
PostgreSQL	15.x	Primary relational database with JSONB support
Redis (Upstash / ioredis)	7.x	Rate limiting via leaky bucket algorithm
Stripe	18.x	Subscription billing and payment processing
Kong	2.8	API Gateway for Supabase services
Zod	3.24	Runtime schema validation for all data boundaries

AI Integration

Provider	Models	Use Case
OpenAI	GPT-5.2, GPT-5.2 Pro, GPT-5.1, GPT-5 Mini	Frontier-quality content generation (Pro default)
Anthropic	Claude Sonnet 4, Claude Sonnet 4.5, Claude Haiku 4.5, Claude Opus 4.5	High-quality analysis and structured output
OpenRouter	Gemini 3 Pro Preview, DeepSeek V3.2, GPT-OSS 120B/20B, GLM-4.6 Exacto	Cost-effective and free-tier model access

DevOps & Infrastructure

Technology	Purpose
Docker	Multi-stage production Dockerfile (build-base → deps → builder → production)
Docker Compose	12-service local development stack
GitHub Actions	CI/CD pipeline for automated Docker image builds and GHCR publishing
Vercel Analytics	Production performance monitoring
pnpm	Fast, disk-efficient package manager

🤖 AI Provider Integration

Model Selection & Routing

flowchart TD
    subgraph UserType["User Classification"]
        Free["Free User"]
        Pro["Pro Subscriber"]
        BYOK["BYOK User<br/>(Bring Your Own Key)"]
    end

    subgraph ModelRouter["Model Router"]
        Default["Default Model Selection"]
        Custom["Custom Model Selection"]
    end

    subgraph Models["Available Models"]
        direction LR
        FreeModels["Free Models<br/>DeepSeek V3.2<br/>GPT-OSS 120B / 20B"]
        ProModels["Pro Models<br/>GPT-5.2 Pro<br/>Claude Opus 4.5"]
        StandardModels["Standard Models<br/>GPT-5.2, GPT-5.1<br/>Claude Sonnet 4/4.5<br/>Gemini 3 Pro"]
    end

    subgraph SDKInit["SDK Initialization"]
        OpenAISDK["@ai-sdk/openai"]
        AnthropicSDK["@ai-sdk/anthropic"]
        OpenRouterSDK["@openrouter/ai-sdk-provider"]
    end

    Free --> Default
    Pro --> Custom
    BYOK --> Custom
    Default --> FreeModels
    Custom --> ProModels
    Custom --> StandardModels
    Custom --> FreeModels
    FreeModels --> OpenRouterSDK
    ProModels --> OpenAISDK
    ProModels --> AnthropicSDK
    StandardModels --> OpenAISDK
    StandardModels --> AnthropicSDK
    StandardModels --> OpenRouterSDK

Model Designation System

Designation	Model	Use Case
`FAST_CHEAP`	Claude Sonnet 4.5	Parsing, simple tasks, quick analysis
`FAST_CHEAP_FREE`	DeepSeek V3.2	Free-tier alternative for fast tasks
`FRONTIER`	GPT-5.2	Complex tasks, deep analysis, best quality
`FRONTIER_ALT`	Claude Opus 4.5	Alternative frontier model
`BALANCED`	Gemini 3 Pro Preview	Good quality with faster/cheaper inference
`VISION`	Claude Sonnet 4.5	Image analysis capabilities
`DEFAULT_PRO`	GPT-5.2	Default for Pro subscribers
`DEFAULT_FREE`	DeepSeek V3.2	Default for free-tier users

Rate Limiting Strategy

Rate limiting is implemented via a leaky bucket algorithm using Redis:

Capacity: 80 messages per 5-hour window (Pro users)
Leak Rate: capacity / duration tokens per second
Storage: Redis hash per user (rate-limit:pro:{userId})
Development: Rate limiting is skipped in NODE_ENV=development

🗄 Database Architecture

Entity-Relationship Diagram

erDiagram
    AUTH_USERS ||--o| PROFILES : "has one"
    AUTH_USERS ||--o| SUBSCRIPTIONS : "has one"
    AUTH_USERS ||--o{ RESUMES : "owns many"
    AUTH_USERS ||--o{ JOBS : "owns many"
    JOBS ||--o{ RESUMES : "linked to"

    AUTH_USERS {
        uuid id PK
        string email
        timestamp created_at
    }

    PROFILES {
        uuid user_id PK,FK
        text first_name
        text last_name
        text email
        text phone_number
        text location
        text website
        text linkedin_url
        text github_url
        jsonb work_experience
        jsonb education
        jsonb skills
        jsonb projects
        jsonb certifications
        timestamptz created_at
        timestamptz updated_at
    }

    SUBSCRIPTIONS {
        uuid user_id PK,FK
        text stripe_customer_id UK
        text stripe_subscription_id UK
        text subscription_plan "free | pro"
        text subscription_status "active | canceled"
        timestamptz current_period_end
        timestamptz trial_end
        timestamptz created_at
        timestamptz updated_at
    }

    RESUMES {
        uuid id PK
        uuid user_id FK
        uuid job_id FK
        boolean is_base_resume
        text name
        text target_role
        text first_name
        text last_name
        text email
        text phone_number
        text location
        text website
        text linkedin_url
        text github_url
        text professional_summary
        jsonb work_experience
        jsonb education
        jsonb skills
        jsonb projects
        jsonb certifications
        jsonb section_order
        jsonb section_configs
        jsonb document_settings
        boolean has_cover_letter
        jsonb cover_letter
        timestamptz created_at
        timestamptz updated_at
    }

    JOBS {
        uuid id PK
        uuid user_id FK
        text company_name
        text position_title
        text job_url
        text description
        text location
        text salary_range
        jsonb keywords
        text work_location "remote | in_person | hybrid"
        text employment_type "full_time | part_time | co_op | internship | contract"
        boolean is_active
        timestamptz created_at
        timestamptz updated_at
    }

Core Tables

Table	Purpose	Key Fields	Security
profiles	User identity and master resume data	JSONB fields for `work_experience`, `education`, `skills`, `projects`	RLS: `user_id = auth.uid()`
resumes	Base and job-tailored resume variants	`is_base_resume` flag, `job_id` foreign key, `document_settings` JSONB	RLS: `user_id = auth.uid()`
jobs	Target job positions and descriptions	`keywords` JSONB, `work_location` enum, `employment_type` enum	RLS: `user_id = auth.uid()`
subscriptions	Stripe subscription lifecycle	`subscription_plan` (free/pro), `subscription_status`, `trial_end`	RLS: `user_id = auth.uid()`

JSONB Data Structures

// Work Experience (stored in profiles.work_experience & resumes.work_experience)
interface WorkExperience {
  company: string;
  position: string;
  location?: string;
  date: string;
  description: string[];    // ATS-optimized bullet points
  technologies?: string[];  // Tech stack tags
}

// Education (stored in profiles.education & resumes.education)
interface Education {
  school: string;
  degree: string;
  field: string;
  location?: string;
  date: string;
  gpa?: number | string;
  achievements?: string[];
}

// Skills (stored in profiles.skills & resumes.skills)
interface Skill {
  category: string;   // e.g., "Programming Languages", "Frameworks"
  items: string[];     // e.g., ["TypeScript", "Python", "Go"]
}

🔄 Application Flow

Resume Management Workflow

flowchart TD
    Start([User Signs Up]) --> CreateProfile["Create Profile<br/>(Master Resume Data)"]
    CreateProfile --> ImportOptions{"Import Method"}

    ImportOptions -->|"Upload PDF/DOCX"| ParseResume["AI Resume Parser<br/>(Text Extraction + Structuring)"]
    ImportOptions -->|"Manual Entry"| ManualInput["Fill Profile Form"]
    ImportOptions -->|"Paste Text"| TextImport["AI Text Analyzer<br/>(Extract & Categorize)"]

    ParseResume --> BaseProfile["Base Profile Created"]
    ManualInput --> BaseProfile
    TextImport --> BaseProfile

    BaseProfile --> CreateBase["Create Base Resume"]
    CreateBase --> BaseResume["Base Resume<br/>(is_base_resume = true)"]

    BaseResume --> AddJob["Add Job Listing"]
    AddJob --> TailorResume["Create Tailored Resume<br/>(AI-Assisted)"]
    TailorResume --> AICurator["AI Content Curator<br/>(Select relevant items)"]
    AICurator --> TailoredResume["Tailored Resume<br/>(is_base_resume = false, job_id linked)"]

    TailoredResume --> AIAssistant["AI Assistant Chat<br/>(Optimize Content)"]
    AIAssistant --> ScoreResume["ATS Score Analysis<br/>(7-metric evaluation)"]
    ScoreResume --> GenerateCover["Generate Cover Letter"]
    GenerateCover --> ExportPDF["Export PDF"]

    style Start fill:#238636,color:#fff
    style BaseResume fill:#1f6feb,color:#fff
    style TailoredResume fill:#8b5cf6,color:#fff
    style ExportPDF fill:#e94560,color:#fff

ATS Scoring Pipeline

flowchart LR
    Resume["Resume Content"] --> Scoring["ATS Scoring Engine"]

    subgraph Scoring["Multi-Factor Scoring"]
        direction TB
        C["Completeness<br/>(Contact Info + Detail Level)"]
        I["Impact Score<br/>(Active Voice + Quantified Achievements)"]
        R["Role Match<br/>(Skills + Experience + Education)"]
        J["Job Alignment<br/>(Keywords + Requirements + Company Fit)"]
    end

    Scoring --> Overall["Overall Score<br/>(0-100)"]
    Scoring --> Improvements["Improvement<br/>Suggestions"]
    Scoring --> Keywords["Matched & Missing<br/>Keywords"]

    style Scoring fill:#f0f6ff,stroke:#58a6ff,stroke-width:2px,color:#000

📁 Project Structure

ApplicaAI/
├── .claude/                        # Claude Code AI configuration
│   └── settings.local.json         # Permission rules
├── .cursor/rules/                  # Cursor IDE rules
│   └── db.md                       # Database schema reference
├── .github/workflows/              # CI/CD pipelines
│   └── docker-publish.yml          # Docker image build & push to GHCR
├── docker/                         # Container infrastructure
│   ├── Dockerfile                  # Multi-stage build (dev + prod)
│   ├── docker-compose.yml          # 12-service local dev stack
│   ├── DOCKER.md                   # Docker documentation
│   ├── entrypoint.sh               # Runtime env injection
│   ├── scripts/                    # Seeding & setup scripts
│   └── supabase/                   # Supabase Docker configs
├── public/                         # Static assets
│   ├── images/                     # Screenshot assets
│   ├── logos/                      # AI provider logos
│   └── *.png, *.webp               # Favicons, thumbnails, OG images
├── src/
│   ├── app/                        # Next.js App Router
│   │   ├── (dashboard)/            # Protected routes
│   │   │   ├── home/               # Dashboard home
│   │   │   ├── profile/            # User profile management
│   │   │   ├── resumes/            # Resume editor & management
│   │   │   ├── settings/           # User settings
│   │   │   ├── subscription/       # Subscription management
│   │   │   └── start-trial/        # Trial onboarding
│   │   ├── admin/                  # Admin panel (impersonation, etc.)
│   │   ├── api/
│   │   │   ├── chat/               # AI streaming chat endpoint
│   │   │   └── webhooks/           # Stripe webhook handlers
│   │   ├── auth/                   # Authentication flows
│   │   ├── blog/                   # MDX blog content
│   │   ├── stop-impersonation/     # Admin impersonation exit
│   │   ├── layout.tsx              # Root layout (auth, header, subscription check)
│   │   ├── page.tsx                # Landing page
│   │   ├── globals.css             # Global styles & CSS variables
│   │   ├── loading.tsx             # Global loading state
│   │   └── error.tsx               # Global error boundary
│   ├── components/
│   │   ├── resume/                 # Resume-specific components
│   │   │   ├── assistant/          # AI chat interface
│   │   │   ├── editor/             # Resume section editors
│   │   │   └── management/         # CRUD operations
│   │   ├── cover-letter/           # Cover letter components
│   │   ├── dashboard/              # Dashboard widgets
│   │   ├── jobs/                   # Job listing components
│   │   ├── landing/                # Landing page components
│   │   ├── layout/                 # Header, footer, navigation
│   │   ├── pricing/                # Pricing page components
│   │   ├── profile/                # Profile management
│   │   ├── settings/               # Settings page components
│   │   ├── subscription/           # Subscription UI
│   │   ├── shared/                 # Shared/common components
│   │   ├── ui/                     # Shadcn UI primitives
│   │   └── magicui/                # Animation components
│   ├── hooks/                      # Custom React hooks
│   │   ├── use-api-keys.ts         # API key management hook
│   │   ├── use-custom-prompts.ts   # Custom prompt management
│   │   ├── use-debounced-value.ts  # Input debouncing
│   │   └── use-toast.ts            # Toast notification hook
│   ├── lib/                        # Core business logic
│   │   ├── ai-models.ts            # AI model registry & configuration
│   │   ├── prompts.ts              # AI system prompts (7 specialized prompts)
│   │   ├── schemas.ts              # OpenAI function calling schemas
│   │   ├── zod-schemas.ts          # Zod validation schemas
│   │   ├── tools.ts                # AI tool definitions (6 tools)
│   │   ├── types.ts                # TypeScript interfaces & types
│   │   ├── rateLimiter.ts          # Redis leaky bucket rate limiter
│   │   ├── redis.ts                # Unified Redis client (Upstash/ioredis)
│   │   ├── blog.ts                 # Blog utilities
│   │   └── utils.ts                # General utilities
│   ├── types/                      # Global type declarations
│   │   ├── html2pdf.d.ts           # html2pdf type declarations
│   │   └── mdx.d.ts                # MDX module declarations
│   ├── utils/                      # Utility functions
│   │   ├── actions/                # Server Actions (organized by domain)
│   │   │   ├── resumes/            # Resume CRUD actions
│   │   │   ├── profiles/           # Profile CRUD actions
│   │   │   ├── jobs/               # Job CRUD actions
│   │   │   ├── cover-letter/       # Cover letter actions
│   │   │   ├── stripe/             # Stripe checkout actions
│   │   │   ├── subscriptions/      # Subscription management
│   │   │   └── utils/              # Shared action utilities
│   │   ├── supabase/               # Supabase client setup
│   │   │   ├── client.ts           # Browser client
│   │   │   ├── server.ts           # Server client
│   │   │   └── middleware.ts       # Session management middleware
│   │   ├── actions.ts              # Dashboard data fetching
│   │   ├── ai-tools.ts             # AI client initialization & SDK routing
│   │   ├── auth.ts                 # Auth helpers with caching
│   │   └── auth-cache.ts           # In-memory auth cache
│   └── middleware.ts               # Root middleware (route protection)
├── schema.sql                      # Complete database schema
├── package.json                    # Dependencies & scripts
├── next.config.ts                  # Next.js configuration (standalone, MDX)
├── tailwind.config.ts              # Tailwind CSS configuration
├── tsconfig.json                   # TypeScript configuration
├── components.json                 # Shadcn UI configuration
├── .env.example                    # Environment variable template
├── CLAUDE.md                       # Claude Code project context
├── LICENSE                         # AGPL-3.0 License
└── README.md                       # This file

🚀 Quick Start

Prerequisites

Requirement	Version	Notes
Node.js	≥ 20.0.0	Required by Next.js 15
pnpm	Latest	Preferred package manager (or npm)
PostgreSQL	15+	Via Supabase (cloud or Docker)
Supabase Account	—	For Auth and database hosting

Installation

# 1. Clone the repository
git clone https://github.com/johnnietse/AI-Powered_Professional_Job_Application_Assistant.git
cd AI-Powered_Professional_Job_Application_Assistant

# 2. Install dependencies
pnpm install

# 3. Configure environment variables
cp .env.example .env.local
# Edit .env.local with your credentials (see Environment Configuration section)

# 4. Initialize database
# Execute schema.sql in the Supabase SQL Editor
# Or via Supabase CLI:
supabase db push --db-url=your_url schema.sql

# 5. Start development server
pnpm dev

Navigate to http://localhost:3000 to start building!

Available Scripts

Command	Description
`pnpm dev`	Start development server
`pnpm dev:turbo`	Start with Turbopack (faster HMR)
`pnpm build`	Create production build
`pnpm start`	Start production server
`pnpm lint`	Run ESLint checks

🐳 Docker Deployment

Architecture: Docker Compose Services

graph TB
    subgraph DockerNetwork["ApplicaAI Docker Network (Bridge)"]
        subgraph SupabaseStack["Supabase Stack"]
            DB[("PostgreSQL 15<br/>:54322")]
            Auth["GoTrue Auth<br/>:9999"]
            REST["PostgREST<br/>:3000"]
            Realtime["Realtime<br/>:4000"]
            Storage["Storage API<br/>:5000"]
            ImgProxy["ImgProxy<br/>:8080"]
            Meta["Postgres Meta<br/>:8080"]
            Kong["Kong Gateway<br/>:54321"]
            Studio["Studio UI<br/>:54323"]
            Analytics["Logflare<br/>:4000"]
            Inbucket["Inbucket<br/>:54324"]
        end

        subgraph CacheLayer["Cache Layer"]
            Redis[("Redis 7<br/>:6379")]
            RedisCmd["Redis Commander<br/>:8081"]
        end

        subgraph AppLayer["Application (Optional)"]
            App["Next.js App<br/>:3000"]
        end

        Seeder["DB Seeder<br/>(runs once)"]
    end

    Kong --> Auth
    Kong --> REST
    Kong --> Realtime
    Kong --> Storage
    REST --> DB
    Auth --> DB
    Realtime --> DB
    Storage --> DB
    Storage --> ImgProxy
    Studio --> Kong
    Studio --> Meta
    Meta --> DB
    Analytics --> DB
    App --> Kong
    App --> Redis
    Seeder --> Auth
    RedisCmd --> Redis

    style DockerNetwork fill:#f6f8fa,stroke:#d0d7de,stroke-width:2px,color:#24292f
    style SupabaseStack fill:#f0fdf4,stroke:#3FCF8E,stroke-width:2px,color:#000
    style CacheLayer fill:#fff1f0,stroke:#DC382D,stroke-width:2px,color:#000
    style AppLayer fill:#f0f6ff,stroke:#58a6ff,stroke-width:2px,color:#000

Quick Start with Docker

# 1. Configure environment
cp .env.example .env.local
# Add at least one AI API key: OPENAI_API_KEY, ANTHROPIC_API_KEY, or OPENROUTER_API_KEY

# 2. Start Docker services
cd docker
docker compose --env-file ../.env.local up -d

# 3. Wait ~60 seconds for services to initialize
docker compose --env-file ../.env.local ps

# 4. Run the app locally (from the project root)
cd ..
pnpm dev

Default Login: admin@admin.com / Admin123 (Pro subscription auto-granted)

Service Endpoints

Service	URL	Description
ApplicaAI App	http://localhost:3000	Main application
Supabase API Gateway	http://localhost:54321	Backend API endpoints
Supabase Studio	http://localhost:54323	Database admin dashboard
Redis Commander	http://localhost:8081	Redis cache management UI
Inbucket (Email)	http://localhost:54324	Local email testing UI
PostgreSQL	localhost:54322	Direct database access

Full-Stack Container Mode

# Run everything in Docker (including the Next.js app)
docker compose --env-file ../.env.local --profile full up

📖 See docker/DOCKER.md for complete Docker documentation.

⚙ Environment Configuration

Required Environment Variables

# ===========================================
# APPLICATION
# ===========================================
NEXT_PUBLIC_SITE_URL=http://localhost:3000

# ===========================================
# AI PROVIDERS (Add at least one)
# ===========================================
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
OPENROUTER_API_KEY=sk-or-...

# ===========================================
# SUPABASE
# ===========================================
NEXT_PUBLIC_SUPABASE_URL=http://localhost:54321
NEXT_PUBLIC_SUPABASE_ANON_KEY=your_anon_key
SUPABASE_SERVICE_ROLE_KEY=your_service_role_key

# ===========================================
# REDIS (Choose one)
# ===========================================
# Local Redis (Docker):
USE_LOCAL_REDIS=true
REDIS_URL=redis://localhost:6379

# Cloud Redis (Upstash):
# USE_LOCAL_REDIS=false
# UPSTASH_REDIS_REST_URL=https://your-redis.upstash.io
# UPSTASH_REDIS_REST_TOKEN=your-upstash-token

# ===========================================
# STRIPE (Optional — for payment testing)
# ===========================================
# STRIPE_SECRET_KEY=sk_test_...
# STRIPE_WEBHOOK_SECRET=whsec_...
# NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_test_...
# NEXT_PUBLIC_STRIPE_PRO_PRICE_ID=price_...

Environment Variable Reference

Variable	Required	Description
`NEXT_PUBLIC_SUPABASE_URL`	✅	Supabase project URL
`NEXT_PUBLIC_SUPABASE_ANON_KEY`	✅	Supabase anonymous key
`SUPABASE_SERVICE_ROLE_KEY`	✅	Supabase service role key (server-only)
`OPENAI_API_KEY`	⚡	OpenAI API key (at least one AI key required)
`ANTHROPIC_API_KEY`	⚡	Anthropic API key
`OPENROUTER_API_KEY`	⚡	OpenRouter API key
`STRIPE_SECRET_KEY`	❌	Stripe secret key (for payments)
`STRIPE_WEBHOOK_SECRET`	❌	Stripe webhook signing secret
`UPSTASH_REDIS_REST_URL`	❌	Upstash Redis URL (cloud deployment)
`UPSTASH_REDIS_REST_TOKEN`	❌	Upstash Redis token

🔄 CI/CD Pipeline

GitHub Actions Workflow

flowchart LR
    subgraph Triggers["Triggers"]
        Push["Push to main"]
        Release["Release Published"]
        Manual["Manual Dispatch"]
    end

    subgraph Pipeline["Build Pipeline"]
        Checkout["Checkout Code"]
        Buildx["Setup Docker Buildx"]
        Login["Login to GHCR"]
        Meta["Extract Metadata<br/>(Tags & Labels)"]
        Build["Build & Push Image<br/>(Multi-stage, cached)"]
    end

    subgraph Output["Published Artifacts"]
        GHCR["ghcr.io/johnnietse/<br/>ai-powered_professional_<br/>job_application_assistant"]
        Tags["Tags:<br/>latest, semver, sha"]
    end

    Push --> Checkout
    Release --> Checkout
    Manual --> Checkout
    Checkout --> Buildx --> Login --> Meta --> Build --> GHCR
    GHCR --> Tags

Trigger	Tag Strategy	Example
Push to `main`	Git SHA	`ghcr.io/.../:abc1234`
Release `v1.2.3`	Semantic versioning	`:1.2.3`, `:1.2`, `:1`, `:latest`
Manual dispatch	Git SHA	`ghcr.io/.../:abc1234`

Docker Build Stages

Stage	Base Image	Purpose	Included In Production
`build-base`	`node:22-slim`	Build tools (python3, make, g++, native deps)	❌
`deps`	`build-base`	Install all dependencies (`pnpm install --frozen-lockfile`)	❌
`development`	`build-base`	Dev server with hot reload	❌
`builder`	`build-base`	Run `pnpm build` with placeholder env vars	❌
`production`	`node:22-slim`	Minimal runtime with standalone output	✅

🔒 Security Model

Defense-in-Depth Architecture

flowchart TB
    subgraph L1["Layer 1: Network"]
        Middleware["Next.js Middleware<br/>Route Protection"]
        Kong2["Kong API Gateway<br/>Request Filtering"]
    end

    subgraph L2["Layer 2: Authentication"]
        GoTrue["Supabase GoTrue<br/>JWT-based Auth"]
        Sessions["Session Management<br/>Cookie-based with Refresh"]
    end

    subgraph L3["Layer 3: Authorization"]
        RLS["Row Level Security<br/>PostgreSQL Policies"]
        SubGate["Subscription Gating<br/>Feature Access Control"]
    end

    subgraph L4["Layer 4: Data"]
        Validation["Zod Schema Validation<br/>All Data Boundaries"]
        Encryption["Supabase Encryption<br/>At Rest & In Transit"]
    end

    L1 --> L2 --> L3 --> L4

    style L1 fill:#e94560,color:#fff
    style L2 fill:#d29922,color:#fff
    style L3 fill:#58a6ff,color:#fff
    style L4 fill:#238636,color:#fff

Security Features

Layer	Mechanism	Implementation
Route Protection	Next.js Middleware	Pattern-based matcher excludes static assets, webhooks, and blog; all other routes require auth
Authentication	Supabase GoTrue (JWT)	Cookie-based sessions with automatic refresh via `updateSession()`
Authorization	PostgreSQL RLS	All 4 tables enforce `user_id = auth.uid()` for both read and write
Subscription Gating	Server-side checks	Pro features gated by subscription plan/status/trial with graceful fallback
Data Validation	Zod schemas	Runtime validation on all API boundaries, server actions, and AI tool outputs
API Keys	Environment variables	Never exposed to client; server-only access via `process.env`
Rate Limiting	Redis leaky bucket	80 requests / 5 hours per Pro user; development mode exempt
Impersonation Safety	Cookie-based flag	Admin impersonation tracked via `is_impersonating` cookie with visible banner

📊 Performance Metrics

Metric	Target	Details
Page Load Time	< 2 seconds	Server-first architecture with React Server Components
Lighthouse Score	95+ (mobile)	Optimized with standalone output and image optimization
AI Response Latency	Real-time streaming	Server-Sent Events via Vercel AI SDK
Concurrent Users	100+	Dockerized with resource limits and connection pooling
Text Extraction Accuracy	95%+	PDF/DOCX/TXT parsing across 50+ resume formats
Document Processing	10,000+ words	Optimized memory usage with streaming
SEO	Structured data + meta tags	OpenGraph, Twitter Cards, JSON-LD ready
Accessibility	WCAG 2.1 AA	Shadcn UI + Radix primitives ensure keyboard and screen reader support

🎥 Demo & Screenshots

Demo Videos

Version	Link
Latest (ApplicaAI v2)	▶️ Watch on YouTube
Original Prototype	▶️ Watch on YouTube

Screenshots

🔄 Transformation Journey

Before & After

Aspect	Initial Version (Prototype)	Current Version (ApplicaAI)
Architecture	Single-file monolithic Streamlit application	Modular Next.js 15 App Router with 15+ organized modules
Code Organization	500+ lines in one file	Separation of concerns across `src/app`, `src/lib`, `src/utils`, `src/components`
AI Integration	Basic Google Gemini API calls	Multi-model system (GPT-5.2, Claude 4.5, Gemini 3, DeepSeek) with Vercel AI SDK
Frontend	Default Streamlit components	React 19, Shadcn UI, Framer Motion, TipTap rich text editor
UI/UX Design	Default Streamlit styling	Professional design system with glassmorphism, animations, responsive layouts
Data Processing	Simple text extraction	Advanced parsing pipeline with structured output and Zod validation
Database	Local-only, in-memory	PostgreSQL + Supabase with RLS, JSONB, automated triggers
Authentication	None	Supabase Auth with JWT, cookie sessions, admin impersonation
Payments	None	Stripe integration with subscription lifecycle and webhooks
Caching	None	Redis leaky bucket rate limiting with dual-client support
Error Handling	Basic try-catch	Comprehensive logging, validation, graceful degradation, error boundaries
Scalability	Local-only, single user	Dockerized 12-service stack supporting 100+ concurrent users
Deployment	`streamlit run main.py`	Docker multi-stage builds, GitHub Actions CI/CD, GHCR publishing
PDF Generation	DOCX export via python-docx	React-PDF with customizable document settings (margins, fonts, spacing)

Technical Innovations & Problem-Solving

1. Complex Problem: ATS Rejection Rates

Problem: 75% of resumes never reach human eyes due to ATS filtering
Solution: Developed a multi-factor scoring algorithm combining keyword matching, semantic analysis, impact scoring, and role alignment
Result: 40% improved match accuracy compared to basic keyword-only approaches

2. Complex Problem: Fragmented Job Search Process

Problem: Job seekers use 5+ separate tools for resume building, company research, and interview prep
Solution: Unified platform with seamless base-to-tailored resume workflow, integrated AI assistant, and cover letter generation
Result: Reduced job search preparation time by 60%

3. Complex Problem: Generic Application Materials

Problem: Generic resumes/cover letters have 80% lower success rates
Solution: AI personalization based on specific job descriptions with tool-calling architecture for precise modifications
Result: Generated materials with 85% higher relevance scores

👥 Use Cases

Persona	Goal	How ApplicaAI Helps
🎓 New Graduate	Stand out in first job search	AI-optimized bullet points, keyword alignment, professional formatting
🔄 Career Changer	Successfully transition to a new field	Tailored resume variants highlighting transferable skills
📈 Professional	Advance to the next level	ATS scoring, quantified achievements, impact-driven language
💼 Freelancer	Attract better clients	Multiple resume versions for different service offerings
🌍 Anyone	Elevate existing resume	One-click AI improvements, cover letter generation, PDF export

🗺 Future Roadmap

Immediate (2026)

Enhanced AI customization algorithms
Expanded resume template library
Advanced PDF styling options
Application tracking dashboard with analytics
LinkedIn profile synchronization

Long Term (Late 2026+)

Mock interview preparation with AI feedback
Salary benchmarking tools
Career trajectory recommendations
Native mobile applications (iOS/Android)
Multi-language resume support
Team/enterprise features

🤝 Contributing

We welcome contributions from developers of all skill levels!

Ways to Contribute

Type	Description
🐛 Bug Reports	Identify and report issues for improvement
💡 Feature Ideas	Share your vision for new capabilities
💻 Code Contributions	Submit pull requests with new features or fixes
📖 Documentation	Improve setup guides, API docs, or tutorials
🎨 Design Work	Refine visual elements and UX flows

Contribution Workflow

# 1. Fork the repository
# 2. Create your feature branch
git checkout -b feature/your-idea

# 3. Make your changes and commit
git commit -m 'Add your feature'

# 4. Push to your branch
git push origin feature/your-idea

# 5. Open a Pull Request with a detailed description

📄 License

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0) — a strong copyleft license designed to ensure that software remains free and open, even when used over a network.

What You Are Allowed to Do

Permission	Description
✅ Commercial Use	Use this project and its derivatives for commercial purposes
✅ Modify	Change, adapt, or extend the source code
✅ Distribute	Share the original project or your modified versions
✅ Patent Use	Contributors grant an express patent license for their contributions
✅ Private Use	Use and modify the software privately without distribution

Conditions You Must Follow

Condition	Description
📋 Preserve Notices	Include a copy of the AGPL-3.0 license and retain existing copyright notices
📝 Document Changes	Clearly state any modifications you make to the original code
📂 Disclose Source	Make the complete corresponding source code available when distributing
🌐 Network Use = Distribution	Running a modified version as a network service requires providing source code to users
🔒 Same License	Distributed modifications must be licensed under AGPL-3.0

See the LICENSE file for complete terms.

🙏 Acknowledgments

OpenAI — GPT-5.2 and frontier language model capabilities
Anthropic — Claude model family for high-quality structured output
Google DeepMind — Gemini models via OpenRouter
DeepSeek — Cost-effective AI inference for free-tier access
Vercel — AI SDK, Next.js framework, and analytics
Supabase — Open-source Firebase alternative (Auth, PostgreSQL, Realtime)
Stripe — Subscription billing infrastructure
Shadcn — Beautiful, accessible component primitives
Radix UI — Headless UI primitives for accessibility

⚠️ Disclaimer

This tool generates AI-powered content that should be reviewed and customized before use. Results may vary based on input quality and API limitations. Always verify company information from official sources. ApplicaAI does not guarantee job placement or interview outcomes.

Built by Johnnie Tse

⭐ Star this repo • Report Bug • Request Feature

Name		Name	Last commit message	Last commit date
.claude		.claude
.cursor/rules		.cursor/rules
.github/workflows		.github/workflows
docker		docker
public		public
src		src
.cursorrules		.cursorrules
.env.example		.env.example
.gitignore		.gitignore
.npmrc		.npmrc
.zshrc		.zshrc
CLAUDE.md		CLAUDE.md
LICENSE		LICENSE
README.md		README.md
components.json		components.json
eslint.config.mjs		eslint.config.mjs
favicon.ico		favicon.ico
next.config.ts		next.config.ts
package.json		package.json
pnpm-lock.yaml		pnpm-lock.yaml
postcss.config.mjs		postcss.config.mjs
schema.sql		schema.sql
tailwind.config.ts		tailwind.config.ts
tests.md		tests.md
tsconfig.json		tsconfig.json

Latest commit

History

Folders and files

Repository files navigation