Inspiration

What it does

About the Project

What Inspired Us

The job interview process is one of the most stressful experiences for job seekers. Many candidates struggle with interview anxiety, lack of practice opportunities, and the inability to get constructive feedback on their performance. Traditional mock interviews require coordinating with another person, scheduling time, and often come with costs or limited availability.

We were inspired to build Intervia after recognizing that:

Accessibility: Everyone deserves access to quality interview preparation, regardless of their network or financial resources
Immediate Feedback: Candidates need actionable insights, not just pass/fail results
Realistic Practice: The best way to prepare for video interviews is to practice in a similar environment
AI Potential: Modern LLMs can provide nuanced, constructive feedback that goes beyond simple keyword matching

Our vision was to create a platform that acts as a coach, not a judge—helping candidates understand their strengths and areas for improvement in a supportive, constructive manner.

What We Learned

Building Intervia was an incredible learning experience that pushed us to explore multiple domains:

Technical Learnings

Full-Stack Architecture: We learned to design a clean separation between frontend and backend, ensuring the API owns all business logic while React focuses purely on presentation. This stateless backend approach made our system more scalable and maintainable.

AI Integration: Working with Groq's API taught us about prompt engineering, JSON parsing from LLM responses, and handling AI failures gracefully. We implemented a mock mode fallback system that allows the application to function even when AI services are unavailable.

Browser APIs: We dove deep into the Web Speech API for both Text-to-Speech (TTS) and Speech-to-Text (STT) capabilities. Learning to handle browser compatibility issues, especially with Chrome's webkitSpeechRecognition, was crucial for cross-browser support.

Real-Time State Management: Managing complex interview state—questions, answers, timers, video streams, and speech recognition—taught us about React hooks, refs, and the importance of cleanup functions to prevent memory leaks.

Authentication Security: Implementing JWT with access and refresh tokens required understanding token rotation, cookie security, and CORS configuration. We learned to balance security with user experience.

Non-Technical Learnings

User Experience Design: We discovered that the language used in feedback matters immensely. Framing evaluations as "What held your readiness back..." instead of "You failed..." creates a more supportive learning environment.

Weighted Scoring Philosophy: We learned that not all questions are equal. Technical questions should carry more weight in scoring, which we implemented using the formula:

$$\text{Overall Score} = \frac{\sum_{i=1}^{n} (s_i \times w_i)}{\sum_{i=1}^{n} w_i} \times 100$$

Where $s_i$ is the score for question $i$ and $w_i$ is its weight (technical questions have $w_i = 2$, behavioral have $w_i = 1$).

Team Collaboration: Working in a hackathon environment taught us to divide responsibilities effectively—backend, frontend, and AI logic—while maintaining clear communication channels and integration points.

How We Built It

Architecture Decisions

We chose a MERN stack (MongoDB, Express, React, Node.js) for its simplicity and our team's familiarity. The architecture follows these principles:

Backend owns logic: All business logic lives in the Express API
Frontend is presentational: React only renders UI and calls endpoints
Stateless backend: No server-side sessions (except database)
REST API: Simple, predictable endpoints without GraphQL complexity
AI abstraction: Easy to swap AI providers through a unified interface

Development Process

Phase 1: Foundation (Days 1-2)

Set up authentication with JWT tokens
Created database models (User, Interview, Job)
Built basic API endpoints
Implemented React routing and protected routes

Phase 2: Core Features (Days 3-4)

Integrated Groq API for question generation
Built interview flow (start → answer → complete)
Implemented answer evaluation with AI
Created report generation system

Phase 3: Enhanced Experience (Days 5-6)

Added Web Speech API for TTS and STT
Integrated webcam with WebRTC
Built timer system for questions
Created weighted scoring algorithm

Phase 4: Polish (Days 7-8)

Improved UI/UX with Tailwind CSS
Added error handling and loading states
Implemented interview history and reports page
Added mock AI mode for testing without API keys

Key Technical Implementations

AI Question Generation: We prompt Groq's Llama 3.3 70B model with job descriptions to generate contextual questions. The prompt engineering ensures a 60/40 mix of technical to behavioral questions, with appropriate weights assigned.

Answer Evaluation: Each answer is evaluated on multiple dimensions—relevance, clarity, depth, and examples. The AI provides constructive feedback that identifies both strengths and areas for improvement.

Report Generation: After all questions are answered, we aggregate individual scores using weighted averages, identify "primary blockers" (questions that most negatively impacted readiness), and generate a comprehensive report with actionable recommendations.

Speech Recognition: We implemented a robust speech-to-text system that handles browser differences, network errors, and provides fallback to manual typing. The system uses interim transcripts for real-time feedback.

Challenges We Faced

Challenge 1: AI Response Parsing

Problem: LLMs don't always return valid JSON, even when instructed to. Sometimes they include explanatory text before or after the JSON.

Solution: We implemented regex-based JSON extraction:

const jsonMatch = response.match(/\[[\s\S]*\]/);
if (!jsonMatch) throw new Error('No JSON in response');
return JSON.parse(jsonMatch[0]);

We also added comprehensive error handling with fallback to mock responses, ensuring the application never crashes due to AI parsing failures.

Challenge 2: Browser Speech API Compatibility

Problem: The Web Speech API has inconsistent support across browsers. Chrome uses webkitSpeechRecognition, while other browsers may not support it at all.

Solution: We implemented feature detection and graceful degradation:

const recognitionSupported = typeof window !== 'undefined' && 
  (window.SpeechRecognition || window.webkitSpeechRecognition);

When speech recognition isn't available, users can still type their answers. We also added clear error messages explaining when internet connectivity is required for speech recognition.

Challenge 3: State Management Complexity

Problem: The interview page manages multiple concurrent states: questions, answers, timers, video streams, speech recognition, and TTS. Coordinating these without race conditions was challenging.

Solution: We used React refs for values that don't trigger re-renders (like timers and recognition instances), and carefully managed cleanup in useEffect hooks. We also implemented refs for answers to ensure the latest state is always available in async callbacks.

Challenge 4: Token Refresh Race Conditions

Problem: Multiple simultaneous API calls could trigger multiple refresh token requests, causing authentication failures.

Solution: We implemented a promise-based locking mechanism:

let refreshPromise = null;

async function refreshAccessToken() {
  if (refreshPromise) return refreshPromise;
  refreshPromise = fetch(...).finally(() => {
    refreshPromise = null;
  });
  return refreshPromise;
}

This ensures only one refresh request happens at a time, even with concurrent API calls.

Challenge 5: Realistic Interview Experience

Problem: Making the interview feel realistic and engaging, not just a form to fill out.

Solution: We added:

Animated AI interviewer video that changes based on speaking state
Text-to-Speech that reads questions aloud
Split-screen layout mimicking real video interviews
Timer pressure (2 minutes per question)
Real-time speech-to-text transcription

These features combine to create an immersive experience that closely mimics actual video interviews.

Challenge 6: Constructive Feedback Tone

Problem: AI can be harsh or judgmental in feedback, which doesn't align with our coaching philosophy.

Solution: We carefully crafted prompts that explicitly instruct the AI to act as a coach:

"Act as a COACH, not a judge.
Use 'What held your readiness back...' NOT 'You failed...'
Be constructive and supportive."

We also implemented post-processing to ensure feedback language matches our supportive tone.

Impact and Future Vision

Intervia successfully demonstrates how AI can democratize access to quality interview preparation. Our weighted scoring system and constructive feedback approach show that technology can be both powerful and empathetic.

Future Enhancements:

Company-side features for pre-screening candidates
Multi-language support
Video recording and playback
Advanced analytics and progress tracking
Integration with job boards
Collaborative features for interview coaches

This project taught us that building with empathy and focusing on user experience is just as important as technical excellence. We're proud of what we've built and excited about the potential to help thousands of job seekers prepare for their dream roles.

Built with passion by Sandro Iobidze, Davit Jincharadze, Juliet Chapidze, and Saba Ananidze for the GDG Kutaisi HACK THE HALLS Hackathon 2025