AI-DRIVEN RECRUITMENT ENGINE

JobPilot
Contextual Intelligence.

We solved the "Generic CV" problem by engineering a Semantic Matching Engine. JobPilot uses vector embeddings to map candidate skills to market demand, rewriting applications in real-time with GPT-4.

Python FastAPI Hexagonal Arch Vector Search Celery Workers
Inspect Architecture View Business Logic
vector-engine://optimizing-context...
JobPilot Dashboard Interface
Match Score: 98.5%
The Problem Space

The "Resume Black Hole" Inefficiency

ATS systems reject 75% of qualified candidates due to keyword mismatch. Manual tailoring is unscalable. JobPilot bridges this gap algorithmically.

Context Loss

Standard PDFs flatten a candidate's multidimensional experience into static text, losing the nuance required for specialized roles.

Matching Friction

Candidates waste hours guessing keywords. We replace guesswork with Vector Clustering to mathematically prove fit.

Conversion ROI

By tailoring syntax and semantics to the specific Job Description (JD), we increase the interview conversion rate by up to 3x.

Engineering Principles

Hexagonal Architecture
(Ports & Adapters)

1

Domain Layer (The Core)

Pure Python entities (User, Job, CV). No frameworks, no DB dependencies. Contains the critical business rules for credit consumption and scoring.

2

Application Layer

Orchestrates Use Cases like OptimizeCV. Defines the interfaces (Ports) that the infrastructure must implement.

3

Adapters (Infrastructure)

Concrete implementations: Supabase for persistence, OpenAI for intelligence, and FastAPI for the driving side.

backend/src/application/use_cases/optimize.py ● Active 
class OptimizeCVUseCase:
    def __init__(self, 
                 cv_port: CVRepository,
                 llm_port: LLMService):
        self.cv_repo = cv_port
        self.llm = llm_port

    async def execute(self, user_id: str, job_id: str):
        # 1. Fetch agnostic domain entities
        cv = await self.cv_repo.get_by_user(user_id)
        job = await self.job_repo.get(job_id)

        # 2. Business Logic (Credit Check)
        if not user.has_credits(5):
            raise InsufficientCreditsError()

        # 3. Call AI Adapter (OpenAI impl)
        optimized_content = await self.llm.optimize(
            context=cv.skills, 
            target=job.requirements
        )
        
        return optimized_content

The AI Engineering Pipeline

We move beyond simple API wrappers. JobPilot orchestrates a multi-step asynchronous pipeline to ensure precision and scalability.

1. Ingestion & Parsing

Raw PDFs are processed to extract structured JSON (Skills, Experience, Education) using custom heuristics and NLP models.

-> Extracted 45 skill nodes

2. Vector Clustering

We generate embeddings for both the Candidate Profile and the Job Description. We calculate Cosine Similarity to find the semantic gap.

-> Similarity Score: 0.72 (Gap Found)

3. Generative Optimization

Using the vector gap as context, we prompt GPT-4 to rewrite specific bullet points to bridge the semantic distance without hallucinating facts.

-> Output: Tailored PDF Generated