promptHire-ai-interview-mocker: PromptHire: The AI Interview Mocker That Turns Your Browser Into the Hiring Panel

A close look at the browser-native loop behind PromptHire, where Gemini generates the questions, speech APIs run the interview, and a feedback table turns every answer into a reviewable lesson.

8 min read • View on GitHub • More from anshuly0720

A job seeker sits at a desk facing a browser window that behaves like an interview panel. The screen is divided into stages that show a spoken question, a live waveform with transcription, and a scoring card with saved notes, which explains how the app conducts and remembers an interview loop. — PromptHire is not just a chatbot in a browser. It is a full interview loop that asks, listens, scores, and stores the result.

Key Takeaways

PromptHire treats the browser as the whole interview engine, not just the place where a chatbot happens to live.
Its real trick is orchestration, since speech synthesis, speech-to-text, JSON prompts, and database persistence work together as one loop.
The app feels cheap to run because it leans on browser APIs and a lightweight Gemini model instead of heavy server infrastructure.
Its database is not storage for its own sake, because every run becomes a reviewable record of answer, feedback, and rating.

The browser is the interviewer here. PromptHire does not stop at generating questions. It speaks them, listens to the answer, grades the response against a stored target, and saves the result for later review. That closed loop is the whole product.

The repo is a clean example of modern AI SaaS design. The value is not a novel model. The value is the way the app chains browser speech APIs, structured prompts, and a relational database into something that feels continuous.

I’m thrilled to announce the launch of PromptHire AI, an intelligent platform built to revolutionize how you prepare for job interviews. Leveraging the power of Google's Gemini AI, PromptHire offers a realistic, interactive interview experience tailored to your specific career goals.

Anshul Yadav, Project Creator · LinkedIn Post

Why this feels different from a typical AI wrapper

Most interview apps split cleanly into two categories. They either give you a text prompt and a form, or they jump straight into live help during a real interview. PromptHire sits in the practice zone and makes that practice feel alive.

Project shape	Input mode	Feedback mode	Cost profile	Realism	Best for
PromptHire	Voice in the browser	AI feedback stored per answer	Low, because it leans on client-side speech APIs and a flash model	Moderate, with enough structure to feel like a session	Mock practice with reusable review
Human-led platforms like interviewing.io and Pramp	Live conversation	Human interviewer critique	Higher, because humans are the product	High, because the pressure is real	Candidates who want live signal
Warmup tools like Google Interview Warmup	Typed or guided answers	Basic automated coaching	Low	Low to moderate	Quick practice and confidence building
Interview copilots like Final Round AI and Verve AI	Live interview assistance	Real-time guidance during the call	Higher, because the product is doing more during the interview	High for assistance, not for practice	People who want help in the moment

That makes the product easier to understand if you frame it as a practice-first system. It is not trying to replace a human interviewer. It is trying to make a rehearsal feel structured enough that the feedback is worth coming back to.

The product is easiest to grasp as a state machine. Every step hands off to the next, and nothing is thrown away until the review page reconstructs the run.

How the interview loop works

The flow starts with a job role, a job description, and a rough experience level. PromptHire feeds that into Gemini and asks for a structured interview set, not freeform prose. The app then strips the markdown wrapper, parses the JSON, and stores the generated interview as a reusable record.

Once the session begins, the browser takes over. The question is spoken aloud through speech synthesis, the user answers out loud, and the browser speech-to-text layer turns that into text. That transcription is then compared with the model answer, and the result becomes feedback plus a rating.

A close-up mechanical relay shows a prompt becoming JSON question cards, then a microphone feeding transcribed text into a feedback engine, and finally a ledger-style answer record stamped with a rating. The image explains how spoken practice becomes a stored evaluation pipeline. — This is the aha moment. PromptHire turns a spoken response into structured data, then turns that data into review.

That feedback page matters more than it first appears. It does not just display one answer in isolation. It reconstructs the relationship between the original question, the user response, the model comparison, and the final rating. In other words, it gives the app memory.

// Simplified flow from the repo
const prompt = buildInterviewPrompt({ role, description, experience });
const response = await gemini.generateContent(prompt);
const questions = JSON.parse(response.text.replace('```json', '').replace('```', ''));

await db.insert(MockInterview).values({
  jobPosition: role,
  jobDescription: description,
  experience: experience,
  jsonMockResp: questions,
});

const transcript = await speechToText(answerAudio);
const feedback = await gemini.compare({ question, answer: transcript, goldAnswer });

await db.insert(UserAnswer).values({
  mockIdRef: interviewId,
  question,
  correctAns: goldAnswer,
  userAns: transcript,
  feedback,
  rating: feedback.rating,
});

What the database is really storing

The schema is simple, but the product logic is strong. MockInterview stores the interview template and generated questions. UserAnswer stores the evidence of each run: the answer, the feedback, the rating, and the link back to the original question.

That distinction is what turns PromptHire from a throwaway demo into a learning tool. The interview session does not vanish when you close the tab. It becomes a record you can audit.

Table	What it stores	Why it matters
MockInterview	Role, description, experience level, generated questions	This is the reusable interview template
UserAnswer	Question, user answer, correct answer, feedback, rating	This is the performance history
Feedback page	Joined view across prior answers	This is where the memory becomes useful

The stack tells you who this is built for

The stack reads like a solo builder’s shortcut to a polished SaaS. Next.js App Router, Clerk, Drizzle, Neon, Tailwind, Gemini, and browser speech APIs are all choices that optimize for shipping fast without building a large backend team around the product.

That is not a criticism. It is the point. PromptHire is designed around managed services and browser capabilities because the product is an orchestration problem, not a deep infrastructure problem.

Layer	Choice in the repo	What it signals
Frontend	Next.js and React	A modern app shell with fast iteration
Auth	Clerk	Authentication without custom plumbing
Data	Drizzle on Neon	Structured data with serverless PostgreSQL
AI	Gemini 2.0 Flash Lite	Low-latency generation for interactive flows
Voice	Web Speech API style tooling	Browser-native input and output

Where PromptHire sits in the market

PromptHire wins by being the simplest product that still feels interactive. It is cheaper and more customizable than human-led mock interview platforms. It is more immersive than a text-only warmup tool. And it is less intrusive than a live copilot that tries to help during the actual interview.

That puts it in a useful niche. It is practice-first, AI-assisted, and browser-native. The trade-off is obvious: you get convenience and low cost, not the realism of a live human interviewer or the deep nuance of a professional coach.

Category	PromptHire's edge	Its limit
Human-led mock interviews	Cheaper and available on demand	Less realistic than a real person
Warmup tools	Voice makes the session feel active	Less deep than dedicated coaching
Interview copilots	Better for practice, not live rescue	No real-time help inside a live job interview
Generic chatbot	Structured loop and saved feedback	Far more opinionated, so less flexible

What this project proves

PromptHire is a good reminder that many useful AI products do not need a new model. They need a tight loop. When the browser can speak, listen, transcribe, and persist state, a thin backend can feel like a much larger system.

That is the larger lesson in this repo. Product value comes from orchestration, from sequence, and from memory. The model matters, but the loop is what makes the experience feel real.