Build an AI Interview App: Intro, Tech Stack & Plan

What We're Building

In this series we'll build an AI interview app with Django, from an empty folder to a working product: you upload a CV, an AI reads it and generates a tailored interview, you answer the questions, and you get feedback. I built the real version of this because I needed it — as a Vietnamese developer, English isn't my first language, and speaking my answers out loud under pressure was the part no amount of reading could fix. Every practice tool I tried buried the actual practice behind sign-ups, paywalls, and setup screens. I wanted to upload my CV and start talking. That gap is the whole reason this project exists.

We'll build it in public, in the exact order I built it. This first part is the map: we see the finished product, choose the stack and justify every choice, plan the features, and scaffold the project. No feature code yet — just the decisions that make the rest of the series go smoothly.

See the Finished App

Before writing a line of code, here's where we're headed — a short demo of the finished, live app:

You can try it yourself right now — it's free and needs no account: ai-interviewer.tech. Everything across these ten parts adds up to this.

Why Python

Python is the base language for one simple reason: the tools we need live here. Resume parsing libraries, the AI SDKs, and nearly every model client are Python-first, so building in Python means fewer bridges and less glue code. It's also fast to write, which matters when you're a solo builder trying to ship. Specifically, this project runs on Python 3.11 — the performance improvements in recent versions are a free win for no extra effort.

Why Django Instead of FastAPI

This is the choice most AI tutorials get wrong by defaulting to whatever's trending. The right question isn't "which framework is fastest?" — it's "what does this app actually need to be good at?" This app isn't a thin API layer; it's a full product with data, an admin surface, and a real user flow. That's Django's home turf:

• Built-in ORM — we model interviews, questions, and answers directly, without wiring up a separate database layer.
• Built-in admin — a ready-made panel to inspect real data while developing, which is invaluable when debugging AI output.
• Batteries included — auth, migrations, forms, and routing come in the box, so we design a whole app fast instead of assembling one piece by piece.

FastAPI is excellent — for pure, high-concurrency async APIs, it's often the better call. But here, the AI calls aren't a concurrency bottleneck, and the time Django's built-in tooling saves outweighs FastAPI's async edge. Choose the tool downstream of your constraints, not the other way around.

Why the OpenAI Agents SDK

For the AI layer, we use the OpenAI Agents SDK — but not for "autonomous agent" magic. The value is the opposite: explicit control over the whole flow. We decide each step and orchestrate it in code, rather than handing the model open-ended freedom and hoping it behaves. Predictable systems come from constraining a probabilistic component, not from trusting it blindly.

• Full flow control — we call the model step by step and keep the logic in our own code, which stays debuggable and reliable.
• Provider-agnostic — through its chat-completions model interface, the SDK can point at any OpenAI-compatible endpoint, including a self-hosted model. We get the SDK's orchestration without being locked to a single provider.

That combination — control plus freedom to swap the underlying model — is exactly what a real product needs, where cost, privacy, or availability might push you to change models later.

Planning the Features

With the stack settled, here's the full feature map for the series, so every later part has a clear place it fits:

• CV upload and text extraction — reliably pulling clean text out of PDF and DOCX resumes.
• Resume validation and role detection — confirming an upload is really a CV, then inferring role and seniority.
• AI-generated questions — a tailored interview grounded in the candidate's actual background, not a generic question bank.
• Voice answers and transcription — answering out loud, the way a real interview works.
• Scoring and feedback — a report the candidate can actually learn from.
• No-login, fast-start UX — the core principle that started the whole project: upload, and go.

Scaffolding the Project

Now we start for real. The shape you give a project on day one decides how much you fight it on day thirty — and an AI app grows extra moving parts (parsing, agents, async work), so a little discipline now pays off later:

• Environment — create a virtual environment on Python 3.11, install Django, and pin your versions in requirements.txt so the build stays reproducible.
• Structure — keep the project and app separated, with clear room for parsing and AI modules to slot in later instead of piling into one file.
• Secrets — put API keys and sensitive settings in environment variables via a .env file from day one, and never commit them.

django-admin startproject ai_interviewer
cd ai_interviewer
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

You can grab the exact requirements.txt used in this project here: requirements.txt.

That's the foundation. We chose each tool on purpose, mapped what we're building, and set up a project that won't need rewriting as the real features arrive. If you'd rather skip the full build and start from the finished, production-ready source, the complete code is available as a starter kit — otherwise, part 2 is next, where we design the database models that turn this plan into a real data shape.