Building an AI-Powered Recruitment Platform

Introduction

Recruitment platforms must serve candidates, recruiters, and interviewers. To make a platform that handles high traffic while generating custom AI interviews, we built a decoupled architecture that runs jobs in background queues and streams updates in real-time.

Background

The platform required three main workflows: resume parser pipelines, AI interview generators that write custom questions based on resumes, and code executors that run candidates' submissions safely. A traditional single-server architecture blocks threads and crashes under high usage.

Implementation

We designed the platform using separate microservices deployed on Google Cloud Run. Communication is routed through a Pub/Sub message broker. Below is an architecture diagram of our system components:

[Web Frontend (Next.js)]
       │ (HTTP / WebSocket)
       ▼
[API Gateway (FastAPI)] ──► [Auth Service (Supabase)]
       │
       ├─► (Pub/Sub Event Broker)
       │         │
       │         ├─► [Resume Parser Worker] ──► [Object Storage]
       │         │
       │         └─► [Interview Gen Worker] ──► [Gemini LLM]
       │
[Candidate Sandbox (Docker Runner)]

Challenges

Building the distributed pipeline presented two major challenges:

• Token usage costs: Re-generating interview questions repeatedly for candidate retries consumed high API budgets.
• Security of code execution: Running untrusted candidate code submissions on the server.

Solutions

We implemented two core solutions:

1. Context Caching: Leveraging Gemini Context Caching to cache base job descriptions, reducing token costs by 70% on subsequent queries.
2. gVisor Sandboxed Containers: Executing candidate code submissions in isolated, short-lived Docker containers sandboxed with Google's gVisor.

Results

Deploying context caching reduced our monthly API expenses from $1,200 to $340, while gVisor sandboxing blocked all unauthorized server access, keeping our runtime environment secure.

Conclusion

Building AI platforms requires architectural discipline. By isolating worker services, leveraging API context caches, and running code evaluations in sandboxed containers, developers build secure, cost-efficient platforms.