PlacementPal: An AI Interview Partner Built for My Friend

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built PlacementPal, an AI-powered interview practice partner for my friend Divya, who is preparing for technical placement interviews.

While preparing for placements, studying concepts and solving problems is only part of the process. Getting realistic interview practice is harder when you don't always have someone available to conduct a mock interview, ask follow-up questions, and point out gaps in your answers.

I built PlacementPal to solve that problem.

The user can choose an interview track:

• DSA
• JavaScript
• HR / Behavioral

They can also choose a difficulty level and start a mock interview.

PlacementPal then:

1. Asks an interview question.
2. Accepts the candidate's answer.
3. Evaluates the answer.
4. Identifies strengths and missing points.
5. Suggests how the answer can be improved.
6. Generates a relevant follow-up question.
7. Produces a final performance summary.

The goal was not to build another generic AI chatbot. I wanted to build something focused on a real problem that someone I know was facing.

What Divya Thought

After building the first version, I shared PlacementPal with Divya.

She liked the idea of having an interview practice partner available whenever she wanted to practice. She particularly liked the combination of answering interview questions, receiving feedback, and getting follow-up questions.

That feedback helped me validate the idea and the direction of the project.

Demo

GitHub Repository:
https://github.com/NirajDN/PlacementPal

Screenshots

Add screenshots of:

1. PlacementPal home page
2. Interview setup
3. Interview question
4. AI evaluation/feedback
5. Follow-up question
6. Final performance summary

The complete source code and setup instructions are available in the GitHub repository.

Code

GitHub:
https://github.com/NirajDN/PlacementPal

The project is organized into a React frontend and Node.js/Express backend.

The frontend contains the interview setup, question interface, answer input, feedback, follow-up, and final results.

The backend contains the interview API, AI service, Gemma provider, prompts, and question bank.

How I Built It

The core AI model for PlacementPal is Google Gemma 2 9B, an open-weight model.

The local architecture is:

React Frontend
      |
      v
Express Backend
      |
      v
PlacementPal AI Service
      |
      v
Ollama
      |
      v
Gemma 2 9B

I use Ollama to make local Gemma inference possible.

The default configuration is:

AI_PROVIDER=ollama
GEMMA_MODEL_NAME=gemma2:9b
OLLAMA_BASE_URL=http://localhost:11434

PlacementPal has separate AI prompts for different interview tasks, including:

• Interview question generation
• Answer evaluation
• Follow-up question generation
• Interview performance summarization

The answer evaluator is designed to return structured feedback including:

• Score
• Correctness
• Strengths
• Missing concepts
• Improvement suggestions
• Ideal answer

The frontend was built using React + Vite, while the backend uses Node.js + Express.

I also implemented a fallback engine so the application can continue functioning when the configured AI provider is unavailable.

Why Does Open Innovation Matter?

I wanted the AI component of PlacementPal to be more than a call to a closed API.

Using an open-weight model such as Gemma makes it possible to run the model locally through Ollama and gives the application more control over how the AI is used.

For an interview preparation tool, users may enter personal preparation information, project details, answers, and areas they need to improve.

With local inference, the application can be configured so that this information stays on the user's own machine instead of being sent to an external AI service.

The open-weight approach also gives the project flexibility:

• The model can be run locally.
• The model can be swapped for another compatible model.
• The prompts and behavior can be customized.
• The AI layer is not permanently tied to one closed API.
• The application can continue evolving with different open models.

For me, that flexibility is the most interesting part of using open AI for this project.

My Agent Session

I used an AI coding assistant while developing PlacementPal, but I am not including a DevRelay agent session in this submission.

Prize Categories

Best Use of Gemma

PlacementPal uses Google Gemma 2 9B, an open-weight model, as its primary AI model.

Gemma is integrated into the core interview workflow rather than being used only for a small feature. The application is designed to use Gemma through Ollama for interview question generation, answer evaluation, follow-up questions, and interview summaries.

What I Learned

Building PlacementPal made me think about AI differently from simply integrating an API.

The interesting part was designing the application around a specific AI role: an interviewer.

The AI needs to understand the interview context, evaluate answers consistently, ask useful follow-ups, and provide feedback that is actually useful to someone preparing for placements.

I also learned that having a fallback mechanism is valuable for AI applications because model availability and inference requirements can affect the user experience.

What's Next

Some improvements I would like to add in the future are:

• Voice-based interviews
• More interview categories
• Persistent interview history
• More detailed performance analytics
• Adaptive difficulty based on previous performance
• Support for additional open-weight models

Conclusion

PlacementPal started with a simple problem: how can I make interview practice easier for someone I know?

Instead of building another general-purpose chatbot, I built a focused interview partner around that specific problem and used an open-weight model as the core of the experience.

That's what made this project interesting for me: building something small, useful, and personal while exploring what open AI makes possible.