ApplicAI: Production-Grade AI Application Suite

🚀 Project Overview

ApplicAI is a comprehensive platform designed to streamline the modern job search process. Leveraging Large Language Models (LLMs), it generates tailored CVs, cover letters, and LinkedIn messages based on specific job descriptions.

What started as a local Python script has evolved into a production-grade SaaS platform serving ~100 daily active users with a 10% conversion rate from visitor to registered user.

This project was my deep dive into full-stack AI engineering, where I architected everything from the database schema to the CI/CD pipelines, focusing on performance, type safety, and user privacy.

🛠️ Technical Architecture

I designed ApplicAI as a modern, decoupled web application to ensure scalability and separation of concerns.

The Frontend: SvelteKit & TypeScript

I chose SvelteKit for the frontend to deliver a highly reactive user experience without the virtual DOM overhead.

Data Visualization: Integrated D3.js to render complex Sankey diagrams, allowing users to visualise their application flow (Rejected → Interview → Offer).
Responsive Design: Built with TailwindCSS, ensuring a native-app feel. I recently resolved specific mobile constraints (like iOS double-tap zoom issues) to ensure a seamless PWA experience.
Type Safety: To maintain robustness across the stack, I implemented a strict type system. The frontend consumes TypeScript interfaces that are automatically generated from the backend models.

The Backend: FastAPI & Python

The core logic resides in a high-performance FastAPI application.

Async Architecture: Utilised async/await throughout the stack, from database queries (using AsyncPG and SQLAlchemy) to AI stream processing. This ensures the server remains non-blocking even when handling multiple concurrent generation requests.
Data Validation: Heavily utilised Pydantic for request/response validation.
End-to-End Type Generation: I wrote a custom shell script (generate_types.sh) that parses Pydantic models and generates equivalent TypeScript definitions (backend.d.ts). This automated pipeline guarantees that the frontend is always in sync with the API contract.

🧠 AI & LLM Operations (LLMOps)

The application integrates multiple LLM providers to balance cost and performance:

Multi-Model Strategy: Supports both Google Gemini (via Google AI Studio) and Meta Llama (via Groq).
Prompt Engineering: developed robust prompts that enforce JSON output formats. This allows the app to reliably extract structured data (like “STAR” format achievements) from unstructured text inputs such as PDFs or DOCX files.
Resilience: Implemented fallback mechanisms and rate-limiting services to handle API quotas gracefully.

☁️ DevOps & Infrastructure

Rather than relying on managed services like Vercel or Heroku, I challenged myself to manage the entire infrastructure stack to understand the “metal” beneath the code.

Self-Hosted VPS: The entire platform runs on an unmanaged Hetzner VPS.
Orchestration: I use Coolify as a self-hosted PaaS to manage Docker containers, database instances, and reverse proxies.
CI/CD: Configured automated pipelines for testing and deployment. The backend utilises Alembic for reliable database migrations, ensuring schema changes are propagated safely in production environments.
Storage: Implemented an S3-compatible storage layer (using Backblaze B2 and boto3) to securely handle user document uploads.

✨ Key Features

Intelligent Parsing: Extracts details from uploaded CVs (PDF/DOCX/ODT) and converts them into structured data objects using AI.
Application Tracking: A Kanban-style tracking system with visual analytics (Heatmaps, Pie Charts, and Word Clouds) to monitor job search progress.
Privacy-First: Users can bring their own API keys (BYOK model), and sensitive data is handled with strict security protocols.
Legacy Support: I also maintain a desktop version of the application (built with PyQt6), keeping the original Python roots alive for users who prefer local-only execution.

💡 Conclusion

Building ApplicAI has been an exhaustive exercise in modern web development. It pushed me to move beyond simple “API wrappers” to building a resilient, type-safe, and self-hosted platform that real users rely on daily to advance their careers.