AWS Builder Center
Building InterviewCoach AI: An Adaptive AI Interview Platform with Amazon Bedrock

Building InterviewCoach AI: An Adaptive AI Interview Platform with Amazon Bedrock

InterviewCoach AI is an AI-powered interview practice platform built for students, freshers, and job seekers. In this article, I explain how I built an adaptive interview system using Amazon Bedrock, S3, Transcribe, and Polly, including the architecture, voice workflow, AI evaluation, challenges, and lessons learned.

Full Stack Developer | C++ & DSA | AI & Backend Development

Building InterviewCoach AI: An Adaptive AI Interview Platform with Amazon Bedrock

Introduction

Preparing for a technical interview is very different from simply studying interview questions.
A student can solve hundreds of DSA problems, learn multiple technologies, and build projects, but still struggle when an interviewer asks a follow-up question such as, "Why did you choose this approach?" or "What would happen if your application had to handle 10 times more traffic?"
This is one of the problems I wanted to solve with InterviewCoach AI.
I built InterviewCoach AI as an AI-powered interview practice platform for students, freshers, and job seekers. The goal is to provide a more personalized and realistic interview experience while helping candidates understand where they need to improve.
The idea is simple:
Practice → Get Evaluated → Identify Weaknesses → Improve → Practice Again



The Problem

Most interview preparation platforms are based around static question banks. You select a topic such as DSA, JavaScript, React, Node.js, or System Design and practice questions one after another.
However, real interviews do not work like that.
A real interviewer listens to your answer and decides what to ask next.
For example, imagine an interviewer asks:
"How did you implement authentication in your project?"
The candidate answers:
"I used JWT for authentication."
A real interviewer might immediately ask:
"Why did you choose JWT instead of session-based authentication?"
Depending on the answer, the interviewer may continue with an even deeper question.
I wanted InterviewCoach AI to reproduce this type of interaction.
That became the central idea behind the project:
The next question should depend on the previous answer.



What is InterviewCoach AI?

InterviewCoach AI is an AI-powered mock interview platform designed for students, freshers, and job seekers.
A candidate can configure an interview using:
  • Target role
  • Experience level
  • Interview personality
  • Text or voice mode
  • Resume
  • Job description
  • Number of questions
The system then creates an interview around that context.
For example, if a candidate's resume contains React, Node.js, MongoDB, JWT, and a particular project, the AI can use that information to ask project-specific questions instead of only asking generic questions.
The same applies to the job description.
If a job description emphasizes C++, DSA, REST APIs, React, and Node.js, the interview can prioritize those areas.



The Core Interview Loop

The core workflow looks like this:
Start Interview → Understand Candidate Context → Generate Question → Candidate Answers → Evaluate Answer → Identify Weak or Missing Areas → Decide Next Question → Follow-up or New Question → Continue Interview → Generate Final Report
This is what makes the system different from a simple AI question generator.
The AI is not only generating questions. It is participating in an interview workflow where previous answers become context for future questions.



System Architecture

I built the application using React, Node.js, Express, MongoDB, and AWS services.
At a high level, the architecture is:
React + Vite Frontend → Node.js + Express Backend → MongoDB + AI Provider Layer + Amazon S3
The AI Provider Layer communicates with Amazon Bedrock, while Amazon S3 handles resumes and voice recordings.
The backend is responsible for authentication, interview state, AI orchestration, database operations, file handling, and AWS service integration.
The frontend communicates only with the backend. AWS credentials are kept on the server side and are never exposed to the React application.



Why Amazon Bedrock?

Amazon Bedrock is the core AI service behind InterviewCoach AI.
I use Bedrock for:
  • Interview question generation
  • Resume-aware questions
  • Job-description-aware questions
  • Adaptive follow-up questions
  • Answer evaluation
  • Strength and weakness identification
  • Final interview reports
  • Personalized improvement plans
One of the things I liked about Bedrock is that it allows me to integrate foundation models through AWS without managing the underlying model infrastructure myself.
It also allowed me to design the application around multiple models instead of tightly coupling the entire system to a single model.



Multi-Model AI Fallback

One of the important engineering decisions in InterviewCoach AI was implementing a multi-model fallback strategy.
The configured model chain is:
Claude 3 Haiku → Amazon Nova Lite → Google Gemma 3 27B
The user does not manually select these models. The backend AI router manages the model selection.
Normally, the primary model, Claude 3 Haiku, handles the request.
If an eligible temporary issue occurs, such as throttling, a service quota-related failure, temporary model availability, or certain service-level failures, the router can sequentially attempt the next configured model.
The flow is:
AI Request → Claude 3 Haiku → Amazon Nova Lite → Google Gemma 3 27B
For example, if Claude encounters an eligible throttling or quota-related failure, the backend can move to Nova Lite. If the next configured model also encounters an eligible failure, the router can move to Gemma.
This approach helps reduce dependence on a single model and makes the AI layer more resilient.
The fallback logic is implemented on the backend, so the user does not need to manually change models.
I also track information such as the model used, latency, and token usage for AI requests. This helps during development, debugging, and monitoring.



Handling Structured AI Responses

Another important engineering challenge was structured AI output.
InterviewCoach AI needs structured information from the AI rather than only plain text.
For example, an evaluation can contain:
  • Technical Accuracy
  • Relevance
  • Depth
  • Clarity
  • Completeness
  • Communication
The backend therefore needs to parse and validate model responses before using them.
I learned that when building an AI application, we cannot simply assume that an LLM will always return perfectly formatted data.
The application needs response parsing, validation, error handling, and controlled recovery around model output.
This became an important part of the AI service layer.



Resume and Job Description Personalization

InterviewCoach AI allows the candidate to upload a resume and optionally provide a job description.
The system uses this information as interview context.
For example, if a resume contains:
  • React
  • Node.js
  • MongoDB
  • JWT
  • REST APIs
the interviewer can ask questions related to those technologies and projects.
Similarly, if a target job description focuses on:
  • C++
  • Data Structures
  • React
  • Node.js
  • APIs
the interview can prioritize those areas.
This makes the interview more relevant to the candidate instead of generating completely generic questions.



Voice Interview

I also wanted the platform to support a voice interview experience.
The voice workflow uses multiple AWS services:
Candidate speaks → Browser MediaRecorder → Node.js Backend → Amazon S3 → Amazon Transcribe → Transcript → Interview Engine → Amazon Bedrock → Next AI Question → Amazon Polly → AI question converted to speech
Amazon S3 stores the voice recording.
Amazon Transcribe converts the candidate's recorded speech into text.
The transcript then goes through the same interview engine that handles text answers.
Amazon Polly converts the AI-generated question into speech so the candidate can hear the interviewer.
I intentionally implemented this as a recorded-answer workflow rather than building a complex real-time WebRTC system. This kept the architecture manageable while still providing a practical voice interview experience.
Another important design decision was to use the same interview engine for both text and voice interviews.
So the application does not have two completely separate interview systems.
The candidate can even switch between text and voice during the same interview without losing the interview state.



Amazon S3

Amazon S3 is used for file-based data.
The application uses S3 for:
  • Uploaded resumes
  • Voice recordings
  • Generated interview audio
I chose S3 because these are file objects rather than structured application records.
MongoDB stores the interview metadata and results, while S3 handles larger file objects.
This keeps the application architecture cleaner.



Amazon Transcribe

Amazon Transcribe is used in the voice interview workflow.
When a candidate records an answer:
Audio → Amazon S3 → Amazon Transcribe → Transcript
The resulting transcript is then passed to the same interview engine that handles text answers.
This means the AI does not need a completely separate evaluation pipeline for voice interviews.



Amazon Polly

Amazon Polly provides the text-to-speech part of the voice interview.
After the interview engine generates the next question, Polly can convert that text into audio.
The candidate can then hear the AI interviewer ask the next question.
This creates a more natural voice-based interview experience compared with displaying only text.



MongoDB

MongoDB is used for structured application data.
The database stores information related to:
  • Users
  • Interviews
  • Questions
  • Answers
  • Evaluations
  • Transcripts
  • Reports
  • Interview history
  • Progress
Large audio files and resumes are not stored directly inside MongoDB. Those are handled by Amazon S3.



Interview Evaluation

After the candidate answers a question, the system evaluates the response across multiple dimensions:
  • Technical Accuracy
  • Relevance
  • Depth
  • Clarity
  • Completeness
  • Communication
The purpose is not simply to produce a number.
The system needs to explain what was good, what was missing, and what the candidate should improve.
For example, an answer can receive separate evaluations for technical accuracy, relevance, depth, clarity, completeness, and communication.
These evaluations contribute to the final interview report.



Final Interview Report

After the interview is completed, InterviewCoach AI generates a detailed report.
The candidate can see:
  • Overall evaluation
  • Category-wise performance
  • Strengths
  • Weak areas
  • Question-by-question feedback
  • Improvement recommendations
  • Personalized 7-day improvement plan
The important part is that the platform does not stop at:
"You scored 72%."
Instead, it tries to answer:
"Where did I struggle, why did I struggle, and what should I practice next?"



Personalized 7-Day Improvement Plan

Based on the weaknesses identified during the interview, the system generates a personalized improvement plan.
For example:
Day 1: Review weak technical concepts Day 2: Practice related problems Day 3: Practice explaining concepts Day 4: Review project-related questions Day 5: Practice follow-up questions Day 6: Take another mock interview Day 7: Review progress
The actual plan is generated based on the candidate's interview performance and identified weaknesses.



Security

Because InterviewCoach AI handles resumes, interview data, and voice recordings, security was an important consideration.
The application includes:
  • JWT authentication
  • Password hashing
  • Protected backend routes
  • User-level data isolation
  • Upload validation
  • File-size limits
  • Private S3 storage
  • Environment variables for secrets
  • AWS credentials kept on the backend
The React frontend never receives the AWS credentials used by the backend.



Monitoring Bedrock Usage

During development, I also used Amazon CloudWatch to understand the behavior of the Bedrock integration.
CloudWatch provides metrics that help monitor:
  • Model invocations
  • Invocation latency
  • Input token counts
  • Output token counts
  • Token usage by model
This was useful while testing the multi-model architecture and understanding how different interview requests were consuming model resources.
It also helped me understand that AI application development is not only about getting a response from a model. You also need visibility into how the system is behaving.



Challenges I Faced

Building InterviewCoach AI involved several challenges.

Designing an adaptive interview

Generating one question is relatively easy.
The harder problem is deciding:
"What should the interviewer ask next?"
The system needs to consider the current question, previous answers, candidate context, and evaluation before deciding the next step.

Working with multiple Bedrock models

Different models can have different request and response formats.
Building an abstraction layer around the models made it easier to keep the rest of the application independent from a specific model.
This became especially important when implementing the fallback strategy.

Structured AI output

The application depends on structured evaluation data.
That means AI output cannot simply be passed directly into the database.
It needs parsing, validation, and error handling.

Voice processing

Voice interviews introduced another chain of dependencies:
Recording → Storage → Transcription → AI Processing → Speech Generation → Playback
Each step can fail independently, so the backend needs proper error handling and state management.

AWS IAM configuration

Working with multiple AWS services also required understanding IAM permissions.
The backend needs appropriate permissions for Bedrock, S3, Transcribe, and Polly.
This was one of the areas where I learned the difference between simply creating an AWS resource and securely allowing an application to use that resource.



What I Learned

This project taught me that building an AI application is much more than connecting an LLM API.
The model is only one part of the system.
A useful AI product also needs:
AI Model + Context + Application Logic + State Management + Validation + Storage + Security + Monitoring + User Experience
I also learned that AWS services become much more useful when each one has a clear responsibility.
For InterviewCoach AI:
Amazon Bedrock → AI intelligence Amazon S3 → File storage Amazon Transcribe → Speech-to-text Amazon Polly → Text-to-speech Amazon CloudWatch → Monitoring



What I Would Improve Next

There are several areas I would like to improve in future versions.

Better interview analytics

I want to provide more detailed long-term analysis of how a candidate's performance changes across multiple interviews.

Improved voice experience

The current voice workflow uses recorded answers. A future version could explore a more real-time conversational experience.

Better skill-gap analysis

The system could compare the candidate's resume, target job description, and interview performance to identify specific skill gaps.

More interview types

Future versions could support dedicated:
  • HR interviews
  • Behavioral interviews
  • System design interviews
  • Coding interviews
  • Managerial interviews

More advanced model routing

The model routing layer could eventually consider factors such as task type, model capability, latency, availability, and usage before selecting a model.



Conclusion

InterviewCoach AI started with a simple question:
How can students and freshers practice interviews in a way that feels more realistic and actually helps them improve?
The result is an AI-powered interview platform that combines:
  • Personalized interview questions
  • Resume and job-description context
  • Adaptive follow-up questions
  • Text interviews
  • Voice interviews
  • AI-powered evaluation
  • Detailed feedback
  • Personalized improvement plans
  • Multi-model AI fallback
Amazon Bedrock provides the intelligence behind the interview system, while Amazon S3, Transcribe, Polly, and CloudWatch support the surrounding workflow.
The biggest lesson I learned while building this project is that an AI application is not just an AI model.
It is the combination of:
AI + Backend Engineering + Cloud Services + Data + Security + User Experience
That is what I wanted to explore with InterviewCoach AI.
Practice smarter. Interview better.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article