Reflexa — Self-Improving AI Interview Agent

Your personal dashboard tracking your journey from baseline to interview-ready.
Launch new sessions automatically queued to test you on the exact areas you struggled with previously.
Track your interview sessions and monitor your overall performance scores over time.
View critical anomalies where the AI failed to push you, alongside its own MCP-powered self-reflection report.
Get a customized, actionable practice plan based on deep analysis of your interview transcripts.
Watch the AI's internal strategy evolve as it generates new rules to target your specific weaknesses.

Inspiration

We’ve all experienced the frustration of technical interviews. Practicing alone often feels like speaking into a void, and while generic AI chatbots can simulate conversations, they don't adapt to your unique weaknesses over time. We realized that a truly effective interview coach shouldn't just ask questions—it should analyze your performance, identify your failure patterns, and adjust its own interviewing strategy for the next session. We wanted to build an AI that learns how to interview you better.

What it does

Reflexa is a self-improving AI interview preparation platform. It doesn't just run mock interviews; it actively learns from them. After every session, Reflexa's "Introspection Agent" analyzes the transcript alongside OpenTelemetry trace data. It identifies where the user struggled (e.g., missed follow-ups, shallow system design answers) and rewrites its own internal strategy rules. The next time the user starts a session, Reflexa uses this updated strategy to push them harder in their weak areas, ensuring measurable improvement over time.

How we built it

We built Reflexa as a full-stack monorepo designed for performance, resilience, and observability.

Frontend: A lightning-fast Vanilla TypeScript SPA built with Vite and styled with Tailwind CSS, deployed on Firebase Hosting.
Backend: An Express 5 API running on Node.js 22, deployed serverless-ly on Google Cloud Run.
Database & Auth: We used Supabase (PostgreSQL) for robust session persistence, strategy history, and Google OAuth.
AI Engine: The core intelligence is powered by Google Gemini 2.5. We implemented Adaptive LLM Routing, using Gemini for real-time chat (with Gemma fallback) and Gemma for heavy analysis tasks (with Gemini fallback) to ensure 100% uptime and gracefully handle rate limits.
Observability & Introspection: We instrumented the entire application with OpenInference and routed our traces to Arize Phoenix Cloud. Our introspection loop uses an MCP (Model Context Protocol) Server to fetch these traces, allowing Gemini to analyze its own past tool calls and execution paths to improve its system prompts.

Challenges we ran into

Serverless Observability: Google Cloud Run aggressively throttles CPU when a request finishes. This caused our background OpenTelemetry spans to get orphaned before they could reach Arize Phoenix. We had to implement a custom manual trace-flushing mechanism that guarantees zero lost spans without blocking the user response.
AI Self-Reflection: Getting an LLM to accurately critique its own past behavior without hallucinating is difficult. We solved this by grounding the Introspection Agent with hard trace data via the Phoenix MCP Server, rather than just feeding it raw text transcripts.
Adaptive Routing: Managing fallbacks between Gemini and Gemma seamlessly required building a robust engine that could catch rate limits or context window errors and automatically retry with the secondary model without the user noticing.

Accomplishments that we're proud of

Successfully creating an AI loop that genuinely rewrites its own system prompt instructions dynamically per user. Seeing the AI jump from a 42% baseline session to a 71% improved session purely based on its own generated rules was incredible.
Achieving 100% trace reliability in a serverless environment through our custom OTEL flushing mechanism.
Building a seamless, real-time UI using Vanilla TypeScript that handles Server-Sent Events (SSE) beautifully.

What we learned

Observability is a feature, not just a debugging tool. By exposing Arize Phoenix traces to the AI via MCP, we turned observability data into actual application context that powers the product's core loop.
Model Orchestration: We learned the nuances of balancing fast, conversational models against heavier, analytical models to optimize both latency and cost.

What's next for Reflexa

Voice-to-Voice Mode: Integrating WebRTC to allow for real-time, low-latency audio interviews, making the experience even closer to a real technical screen.
Custom Code Execution: Adding a sandboxed environment so the AI can evaluate actual code compilation and test results during the interview.
Team & Cohort Analytics: Allowing bootcamp instructors or engineering managers to see aggregate weakness trends across multiple users.