ATS & Scraper Pro - AI-Powered Resume Suite

📌 Overview

ATS & Scraper Pro is a comprehensive, professional Windows Desktop application designed to bridge the gap between candidates and opportunities. It provides a robust suite of tools for resume analysis, complex job description matching, and automated multi-platform job sourcing—all operating securely and locally on your machine. Originally a web API, it uses a Desktop-First Architecture for maximum privacy and performance.

🏗️ Architecture

The system follows a modern, decoupled local-first architecture packaged into a standalone desktop application:

• Desktop Shell / Frontend: A sleek, custom Windows UI powered by React, Vite, and Tailwind CSS.
• Local Backend Engine: A high-performance Python (FastAPI) server running locally to handle business logic, AI scoring, and local DB operations.
• Scraping Engine: A stealthy, automated job scraper built with Playwright, capable of bypassing bot detection.
• Database: A lightweight, file-based SQLite database managed via SQLAlchemy ORM for fast local storage.

📁 Folder Architecture

A modular structure ensures maintainability for this hybrid desktop application:

ATS_Pro/
 ├── backend/            # Core logic & Local API
 │   ├── app/            # FastAPI Application Code
 │   │   ├── api/        # Local endpoints
 │   │   ├── core/       # Configurations & security
 │   │   ├── db/         # SQLite DB configuration
 │   │   ├── models/     # SQLAlchemy database schema
 │   │   └── services/   # AI Scoring & business logic
 │   ├── uploads/        # Local storage for parsed documents
 │   └── main.py         # Backend entry point
 ├── frontend/           # React/Vite source code
 ├── scripts/            # Platform-specific Playwright scraping modules
 ├── tests/              # Test suites (Performance, K6, etc.)
 ├── ATS_Pro.spec        # PyInstaller configuration
 └── ats_installer.iss   # Inno Setup Windows installer script

📊 Architecture Diagram

graph TD
    User((User))
    subgraph "Desktop Frontend (React/Vite)"
        UI[Sleek UI Components]
    end
    subgraph "Local Backend Engine (FastAPI)"
        API[Local REST API]
        AI[AI Scoring Engine]
        Scraper[Playwright Stealth Scraper]
    end
    subgraph "Local Data Layer"
        DB[(SQLite Database)]
        FS[Local File System]
    end
    subgraph "External Job Portals"
        LinkedIn[LinkedIn]
        Indeed[Indeed]
        Naukri[Naukri]
    end

    User <--> UI
    UI <--> API
    API <--> AI
    API --> Scraper
    API <--> DB
    API <--> FS
    Scraper <--> LinkedIn
    Scraper <--> Indeed
    Scraper <--> Naukri

Loading

🔄 System Request Flow

• Request Initiation: The desktop client (React frontend) sends an internal HTTP request to the local FastAPI server (e.g., POST /api/score).
• Local Validation: The backend validates the request payload and ensures local file paths are accessible.
• Service Logic: The local FastAPI controller handles the core business logic, querying or updating the local SQLite Database via SQLAlchemy.
• AI Processing: For scoring tasks, the text is passed to the local ONNX-integrated AI engine for TF-IDF and NLP analysis.
• Queueing (Optional): If the task is a long-running job (like multi-platform scraping), it's processed asynchronously in the background via the Playwright worker.
• Response: The local server returns a JSON response back to the React frontend, instantly updating the UI without network latency.

🗄️ Database Schema

The system uses a relational SQLite schema managed by SQLAlchemy. Below are the core models:

model Resume {
  id               Integer   @id
  filename         String
  content          Text
  uploaded_at      DateTime
  candidate_name   String?
  skills           JSON?
  experience_years Float?
  results          AnalysisResult[]
}

model JobDescription {
  id                 Integer   @id
  title              String
  raw_text           Text
  extracted_features JSON?
  results            AnalysisResult[]
}

model AnalysisResult {
  id               Integer   @id
  resume_id        Integer   @foreignKey
  jd_id            Integer   @foreignKey
  overall_score    Float
  feedback         JSON
  metadata_info    JSON
}

Key Relationships: An AnalysisResult bridges one Resume and one JobDescription, allowing one resume to be scored against multiple jobs over time.

🛠️ Tech Stack

Frontend Shell

• Framework: React, Vite
• Styling: Tailwind CSS, shadcn/ui

Backend Engine

• Runtime: Python 3.11+
• Framework: FastAPI (Localhost server)
• ORM: SQLAlchemy (SQLite)

AI & Automation

• Scraping: Playwright with Stealth Plugin
• AI Scoring Engine: Custom NLP/TF-IDF models (ONNX integration)

Packaging & Deployment

• Executable: PyInstaller (onedir mode)
• Installer: Inno Setup

🧩 Core Features & Modules

Instead of exposing external web endpoints, the local engine handles operations via modular internal features:

• Document Parsing: Extracts structural data from PDFs and DOCX files.
• AI Scoring (/api/score): Compares extracted resume skills/experience against Job Descriptions.
• Scraping Engine (/api/scrape): Initiates multi-threaded scraping tasks across LinkedIn, Indeed, Glassdoor, Naukri, and Internshala.
• Settings & Config: Manages API keys, scraping limits, and application preferences locally.

🛡️ Privacy & Security

ATS & Scraper Pro prioritizes user data privacy with a Local-First approach:

• No Cloud Storage: Unlike web-based ATS tools, your resumes and analysis results never leave your machine (except for necessary search queries sent to job portals).
• Local Database: All persistent data is stored securely in %LOCALAPPDATA%\ATS_Pro_AI or within the application directory.
• No Telemetry: No tracking of user interactions or scraped candidate data.

⚙️ Automated Scraping Jobs

Heavy, asynchronous scraping tasks are delegated to background processes to prevent blocking the UI thread. The system utilizes Playwright Stealth to navigate bot protections and rate limits imposed by job boards, pacing requests locally.

📈 Local Performance & Load Testing

Tests conducted using k6 against the local FastAPI engine (measured on 2026-05-27).

Test Type	Metric	Performance	Status
Load Test	p(95) Duration	2.84ms (80 req/s)	✅ PASS
Stress Test	Max Throughput	137 req/s (11,075 reqs)	✅ PASS
Spike Test	Recovery	Handled 200 VUs at 105 req/s	✅ PASS
Soak Test	Stability	100% Succeeded (21,020 reqs)	✅ PASS
Breakpoint	Breaking Point	Handled 2000 VUs at ~1359 req/s	✅ PASS

Context: Because the application runs entirely on localhost without external network latency (except during active web-scraping), the local FastAPI server boasts exceptional baseline throughput. Tests verify the SQLite locking mechanisms remain stable under concurrent local access.

🚀 Setup Instructions

Prerequisites (For Development)

• Python 3.11+
• Node.js (for frontend compilation)
• Inno Setup (for building the installer)

1. Developer Setup

Clone the repository and navigate to the project root.

# Setup Backend
cd backend
python -m venv venv
.\venv\Scripts\activate
pip install -r ../requirements.txt

# Setup Frontend
cd ../frontend
npm install
npm run build

2. Running Locally for Development

You will need to run the backend and frontend concurrently.

# Terminal 1: Backend
cd backend
uvicorn app.main:app --reload --port 8000

# Terminal 2: Frontend
cd frontend
npm run dev

3. Packaging & Building the EXE

To compile the standalone Windows executable:

1. Ensure dependencies are installed and the frontend is built.
2. Run PyInstaller from the root directory:

   pyinstaller ATS_Pro.spec --noconfirm

3. Use Inno Setup to compile ats_installer.iss into the final Setup.exe.

For End Users

1. Download the latest ATS_Scraper_Setup.exe.
2. Run the installer and follow the on-screen instructions.
3. Launch "ATS & Scraper" from your Desktop or Start Menu.