MockInterviewer

"Ditch passive chatbots. InterviewOS is an evidence-driven AI interviewer that maps resume vulnerabilities, executes live code in Docker sandboxes, and actively pushes back on weak answers."

Comment

Inspiration

Most AI interview tools on the market share a fatal flaw: they are just passive chatbots. They ask a generic question, you give a mediocre answer, and they say, "Great job! Next question." But real senior engineering interviews don't work like that. Real interviews involve pressure, skepticism, and pushback. We wanted to build an evidence-driven interview simulator that doesn't just test your trivia knowledge, but actively tests your ability to defend your technical decisions, write code under pressure, and recover when you make a mistake.

What it does

InterviewOS (MockInterviewer) is a full-stack, real-time technical interview simulator with four core pillars:

  • The Vulnerability Map: Before the interview even starts, it cross-references your uploaded resume against the target job description to highlight "High-Risk" claims (e.g., claims lacking metrics or deep technical evidence) so you know exactly where the interviewer will attack.
  • The Adaptive Recovery Engine: During the WebSocket-powered chat, if you provide a flawed time complexity or a weak architectural answer, the AI triggers a "Pushback Protocol." Instead of moving on, it challenges your logic and scores your ability to adapt and correct yourself under pressure.
  • The Live Code Sandbox: Features an integrated Monaco code editor where candidates write code. The platform spins up an ephemeral Docker container to safely execute the code and streams the stdout back to the UI in real-time.
  • Counterfactual Feedback: The post-interview Analytics Dashboard doesn't just give you a generic score. It quotes your exact chat text and provides counterfactuals, showing you precisely what you should have said to pass.

How we built it

We architected the platform with a heavy emphasis on real-time event streaming and strict AI constraints.

  • Frontend: Built with Next.js (App Router), React, and Tailwind CSS for a clean, developer-centric terminal aesthetic.
  • Backend: Powered by Python and FastAPI, handling concurrent WebSocket connections for the live interview chat.
  • AI Engine: Integrated with Google Gemini. We utilized strict Pydantic JSON schemas to force the LLM to output structured data (risk scores, recovery metrics) rather than just conversational text.
  • Database: A MySQL database handles the event-sourced storage of the interview session, tracking claims, challenge events, and final scorecards.
  • Infrastructure: Dockerized the backend and database, and heavily utilized the Docker SDK within Python to spawn isolated, ephemeral sandboxes for evaluating candidate code on the fly.

Challenges we ran into

Building a production-grade local environment surfaced several intense infrastructure bottlenecks:

  • Dependency Resolution Loops: While setting up the Python backend, we encountered massive backtracking loops with pip trying to compile C-extensions for modern Python versions. We bypassed this by migrating to uv, an ultra-fast Rust-based package installer.
  • Docker DNS & Networking: We ran into classic Windows Docker Desktop bugs where the daemon lost DNS resolution, crashing our image builds. We engineered workarounds by injecting SQL migration files directly into the active container using docker cp and executing them internally.
  • State Management: Forcing a highly conversational LLM to act as a strict, state-driven evaluator required deep prompt engineering to prevent it from breaking character or dropping the JSON schema mid-interview.

Accomplishments that we're proud of

  • The Pushback Protocol: Successfully making the AI "argue" constructively with the user. It completely changes the dynamic from a Q&A bot to a rigorous technical screen.
  • The Ephemeral Sandbox: Integrating the Docker daemon to securely run arbitrary user code and return the output via FastAPI without crashing the host environment.
  • Full-Stack Cohesion: Seamlessly wiring up Next.js components to reflect complex, real-time backend state changes over WebSockets.

What we learned

  • The raw power of structured LLM outputs (using Pydantic validation) to drive complex backend logic.
  • How to deeply debug Docker networking, volume mounting, and pipeline execution within local development environments.
  • That bypassing traditional package managers like npm and pip in favor of tools like npx and uv can save hours of dev time when environments get corrupted.

What's next for MockInterviewer

  • Cloud Deployment: Containerizing the entire stack for deployment on Vercel (Frontend) and AWS/Render (Backend).
  • Multi-Language Support: Expanding the Docker sandbox to execute and evaluate Python, C++, and JavaScript code snippets alongside Java.
  • Voice Integration: Implementing WebRTC and Speech-to-Text to allow candidates to speak their technical answers naturally, bringing it one step closer to a human interview experience.

Built With

Share this project:

Updates