DEV Community: Qingyuan Yang

How We Built a Self-Hosted AI Interviewer with Next.js, Supabase, and WebSockets

Qingyuan Yang — Sun, 19 Jul 2026 09:05:09 +0000

Most interview software helps someone schedule, record, or score a conversation. We wanted to build the interviewer itself: a system that could generate a structured interview, conduct it over voice, chat, or video, ask follow-up questions when an answer was vague, and turn the result into a useful report.

That became Aural, which we have released under the MIT license.

What the system needs to do

A useful AI interviewer needs more than a list of questions. It must:

turn a plain-language brief into a coherent interview structure;
keep state across a real-time conversation;
decide when an answer needs a contextual follow-up;
support text, audio, and video without splitting the product into separate workflows;
produce transcripts, evidence, scores, and summaries that a human can inspect;
give teams control over their data and model provider.

The last point is why open source matters here. Interviews can contain resumes, personal information, recordings, and evaluations. Teams should be able to inspect how that data moves through the system and, when needed, run the entire stack on their own infrastructure.

Architecture

Aural is a TypeScript application built with Next.js 14 and the App Router. Supabase provides PostgreSQL, authentication, storage, and real-time subscriptions. tRPC keeps client and server calls type-safe, while Tailwind CSS, shadcn/ui, and Radix primitives provide the UI layer.

For technical interviews, Monaco powers the code editor and Excalidraw provides a collaborative whiteboard.

The core separation is between the interview definition, the live session, and the assessment result.

The definition describes competencies, questions, timing, modality, and evaluation criteria.
The session records the live conversation, current state, follow-up decisions, and integrity events.
The assessment transforms session evidence into per-competency scores, summaries, themes, and engagement metrics.

Keeping these concerns separate lets the same interview run over chat, voice, or video while preserving one reporting model.

Adaptive follow-ups

A scripted questionnaire advances after every response. An interviewer needs another decision: did the answer actually provide enough evidence?

After each response, Aural evaluates the answer against the active question and its criteria. The model can ask a focused follow-up, clarify ambiguity, or continue to the next question. The goal is not to make the model talk more; it is to collect comparable evidence without forcing every participant through an identical conversational path.

We also store the resulting transcript and question context. That makes a score traceable to what was asked and answered instead of leaving users with an unexplained number.

Real-time voice and video

Audio and video add failure modes that do not exist in chat: connection drops, partial transcripts, device permission errors, silence, and out-of-order events. We use persistent session state and WebSocket relays so the interface can recover without losing the interview's position.

The UI treats the transcript as a first-class artifact. Live speech events update the conversation, but the durable session record remains the source of truth for assessment and reporting.

Self-hosting

The repository includes the complete application rather than a limited community edition. A local setup follows the familiar Next.js workflow: clone the repository, copy .env.example to .env.local, install dependencies, and run the development server.

You configure Supabase credentials, model-provider keys, and the integrations you want. Production options include Docker, Vercel, and conventional server deployment. Supabase can be managed or self-hosted.

The model layer supports OpenAI-compatible providers so a deployment is not tied to one vendor. That is useful for cost control, data residency, and teams that already operate an internal model gateway.

What is included

The open-source release contains the interview designer, adaptive chat/voice/video sessions, automated assessment, candidate and session management, Monaco coding interviews, Excalidraw whiteboards, integrity controls, multilingual support, organizations, projects, and role-based access.

We kept the hosted product as an option for teams that do not want to manage infrastructure. Both paths use the same codebase: self-host when data sovereignty and customization matter, or use the managed service when operational simplicity matters more.

What we learned

The hardest part was not generating questions. It was building a reliable loop around the model: durable session state, bounded follow-ups, modality-independent reporting, observable evidence, and recovery when real-time media fails.

An AI interviewer should not be a black box that emits a confident recommendation. The useful output is the evidence trail: what was asked, what the participant said, how criteria were applied, and where a human should review the result.

The source is available on GitHub. Feedback on the self-hosting experience, scoring transparency, and real-time interview flow is especially welcome.

Originally published on the Aural blog.

Open-source AI Interview Platform for chat/voice/video

Qingyuan Yang — Thu, 16 Jul 2026 02:06:02 +0000

Qingyuan Yang

Jul 15

Building a Self-Hosted Voice AI Interview Platform with Next.js, Supabase, and WebSockets

#opensource #ai #webdev #nextjs

4 min read

Building a Self-Hosted Voice AI Interview Platform with Next.js, Supabase, and WebSockets

Qingyuan Yang — Wed, 15 Jul 2026 06:45:15 +0000

Aural started with a simple limitation: static question banks and chatbots do not reproduce the rhythm of a real interview. A useful interview system needs to listen, decide when to probe, preserve context, and produce feedback that is consistent enough to act on.

I built Aural as an open-source platform for conducting interviews over voice, chat, and video. Teams can design an interview, share a link, let the AI ask contextual follow-up questions, and receive a structured report. Candidates can also use the same core workflow for practice.

This post covers the engineering decisions that mattered most when moving from a chat prototype to a self-hostable, real-time product.

What the platform needs to do

A single interview touches several subsystems:

interview configuration and question sequencing
real-time voice, chat, or video interaction
adaptive follow-up generation
coding and whiteboard exercises
transcript storage and cleanup
structured scoring and report generation
organization, project, and access controls

The important design decision was to treat an interview as a stateful workflow, not a series of independent prompts. Every answer changes what the system knows and what it should ask next.

Why voice is harder than chat

Chat gives the application a clean turn boundary: the user presses Send. Voice does not. A real-time interview has to infer when a candidate has finished, handle pauses and filler words, and avoid interrupting a thought that is still developing.

Three problems dominated the implementation.

1. Latency is part of the user experience

Every stage adds delay: audio capture, transport, transcription, follow-up generation, speech synthesis, and playback. Optimizing only the model call is not enough. The entire path has to stream wherever possible, and each hop needs timing data so regressions are visible.

2. Raw transcripts are not reliable application state

Speech recognition output can contain partial phrases, duplicates, false starts, and punctuation changes. Aural keeps the live transcript useful for the interface while normalizing the final answer before it becomes durable interview context. That separation prevents temporary transcription artifacts from polluting later questions and reports.

3. Follow-ups must feel earned

A generic request to elaborate quickly sounds scripted. The follow-up generator receives the interview goal, current question, normalized answer, previous turns, and remaining depth budget. It must either ask a focused follow-up or explicitly move on. A configurable depth limit keeps the conversation useful without letting one answer consume the whole session.

Conceptually, the loop looks like this:

Capture and normalize the candidate response.
Persist the turn and update interview state.
Decide whether the answer needs a follow-up.
Generate the next prompt under the configured depth and time limits.
Stream the prompt back through the active communication channel.
Finalize scoring only after the turn history is stable.

The architecture

Aural uses Next.js and TypeScript for the application, Supabase/PostgreSQL for durable data, tRPC for typed application APIs, and WebSocket relays for real-time voice events. LLM providers are behind adapters so a self-hosted deployment is not tied to one vendor.

The data plane and the AI plane are deliberately separated. Product state such as organizations, interviews, sessions, questions, permissions, and reports lives in PostgreSQL. Model calls receive only the scoped context needed for the current operation. This makes authorization easier to reason about and gives operators a clear place to enforce retention policies.

Long-running operations are also separated from the live turn path. Report generation can be retried without replaying the interview, while the real-time path stays focused on responsiveness.

Structured evaluation instead of one opaque score

An overall number is easy to display but hard to trust. Aural evaluates answers against explicit dimensions and keeps the evidence connected to the transcript. The report can therefore show what worked, what was missing, and what to improve next rather than returning a mysterious score.

The same structure powers candidate practice. Instead of ending with a report alone, the system can turn weaknesses into a revision prompt, a suggested answer outline, or another practice attempt.

Self-hosting and data ownership

Interview data can include resumes, job descriptions, recordings, transcripts, and internal hiring criteria. For many teams, where that data lives is not a minor deployment detail.

The open-source release includes Docker-based self-hosting and documented environment configuration. Operators can choose their database, storage, and supported model provider, then place the deployment inside their own network and retention controls. The hosted service remains useful for teams that do not want to operate the stack, but self-hosting is a first-class path rather than an export feature.

What I learned

The biggest lesson is that a believable AI interview is a systems problem. Prompt quality matters, but so do turn detection, streaming, transcript hygiene, state transitions, authorization, observability, and failure recovery. Improving any one component in isolation has limited value if the full conversation still feels slow or inconsistent.

A second lesson is to keep model output constrained by product state. Follow-up depth, remaining time, question goals, evaluation rubrics, and permitted tools should be explicit inputs. The model should not silently invent the workflow.

Try Aural

Live demo without signup: aural-ai.com
Source code: github.com/1146345502/aural-oss
License: MIT

Feedback is especially welcome on the self-hosting workflow, real-time voice experience, and the privacy boundaries you expect around interview data.