DryRunAI

Practice the interview before it counts.

An AI interviewer that asks real questions, watches you code, and pushes back when you're stuck - out loud, like the real thing.

Why

Most practice tools grade a final answer. Real interviews don't work like that - you think out loud, get follow-ups, and have to handle a nudge without losing the thread. DryRunAI is built to rehearse that specific skill: the conversation, not just the code.

Features

• Real voice conversation - powered by Pipecat, Deepgram Flux (streaming speech-to-text with built-in end-of-turn detection) and Deepgram Aura-2 text-to-speech, with Silero VAD for natural barge-in - interrupt the interviewer mid-sentence like you would a real person.
• Clarifying questions first - nothing gets coded until the constraints are nailed down. It won't hand you the edge cases; you have to ask.
• Sees your code as you write it - periodic snapshots of your editor, not a live keystroke feed, close enough to follow your actual approach.
• Adaptive hints - the smallest hint that unblocks you when you're stuck, never the full solution.
• Two interviewer personas - Neutral & realistic, or Strict & high-bar.
• A real scorecard at the end - correctness, complexity, problem-solving approach, communication and a hire / no-hire verdict across every problem you attempted, shown on a report page and persisted alongside the full transcript for later review.
• Multi-problem interviews - choose 1-4 problems per session. Solve one well and the next is harder; get stuck and the interviewer moves you on to another at the same level. You can also end the interview any time and get scored on everything you attempted.
• 50-problem bank spanning Arrays, Strings and Linked Lists across Easy/Medium/Hard.

Not built yet: running your code against test cases (the interviewer reads your code, it doesn't execute it), Java, and a real code editor (it's a plain text box for now).

Tech stack

Frontend	Next.js (App Router), TypeScript, Tailwind CSS
Backend	Python, FastAPI
Voice orchestration	Pipecat
Speech-to-text	Deepgram Flux
Text-to-speech	Deepgram Aura-2
Turn-taking / barge-in	Silero VAD
LLM	Groq (openai/gpt-oss-120b) - live conversation + scorecard

Runs entirely locally - no hosting, no database, no auth in the current version. Session transcripts, code snapshots, and scorecards are written to local JSON files.

Getting started

Prerequisites:

• Node.js 20+ - check with node --version
• Python 3.13+ - check with python --version (the pinned dependencies include audioop-lts, which doesn't install on older versions)
• A Deepgram API key
• A Groq API key

1. Clone the repo

git clone https://github.com/yuvraj-kumar-dev/DryRunAI.git
cd DryRunAI

2. Configure environment variables

There's a single .env at the repo root, shared by both frontend and backend.

cp .env.example .env

Open .env and fill in:

DEEPGRAM_API_KEY=your_deepgram_key_here
GROQ_API_KEY=your_groq_key_here
GROQ_MODEL=openai/gpt-oss-120b   # default; needs a Groq model that supports tool calling
BACKEND_PORT=8000
NEXT_PUBLIC_BACKEND_URL=http://localhost:8000

3. Start the backend

In one terminal, from the repo root:

cd backend
python -m venv .venv

Activate the virtual environment:

.venv\Scripts\activate       # Windows (cmd/PowerShell)
source .venv/bin/activate    # macOS/Linux

Install dependencies and start the server:

pip install -r requirements.txt
uvicorn app.main:app --reload --port 8000

Verify it's up - in a second terminal:

curl http://localhost:8000/health

You should get back {"status":"ok"}. If GROQ_API_KEY/DEEPGRAM_API_KEY are missing, check GET /config/status for which ones the server actually loaded from .env.

4. Start the frontend

In a new terminal (leave the backend running), from the repo root:

cd frontend
npm install
npm run dev

5. Start a session

Open http://localhost:3000 in your browser. Click Start practicing, pick a category, starting difficulty, interviewer style and number of problems, and grant microphone access when prompted - DryRunAI needs it for the live voice conversation. The interviewer greets you first; wait for it to finish before responding, or just interrupt it like a real conversation. Press End any time to stop and get your scorecard.

Project structure

frontend/          Next.js app (marketing homepage, /practice picker, /interview, /report)
backend/
  app/
    main.py          FastAPI routes (sessions, code snapshots, end/report, /ws/voice)
    voice.py         Pipecat voice pipeline + interviewer tools
    session_state.py Session state + problem progression (no Pipecat imports)
    interview.py     Persona prompts + scorecard generation
    problems.py      Problem bank loader/selection
    data/            The 50-problem bank
  scripts/           text_interview.py (full interview in a terminal), check_progression.py
sessions/           Persisted session transcripts (local only, gitignored)