ArchCoach_ AI powered

Inspiration

What it does Inspiration

System-design interviews are difficult to practice realistically. Most resources provide static questions or reference architectures, but they don't reproduce the back-and-forth of an actual interview.

I built ArchCoach to turn system-design practice into an interactive interview experience where an AI interviewer can ask follow-up questions, challenge architectural decisions, and provide feedback based on the candidate's reasoning.

What ArchCoach Does

ArchCoach is an AI-powered mock system-design interviewer.

A user selects a system-design problem such as:

URL Shortener
Chat Application
Rate Limiter
News Feed

They then choose an interview level:

Junior
Senior
Staff

The AI interviewer presents the problem and adapts its questions to the selected level.

During the interview, the candidate can explain their architecture using voice or text while designing the system on an interactive whiteboard.

How It Works

The application is built with Next.js 14, TypeScript, Tailwind CSS, Excalidraw, Web Speech API, Zod, and the Anthropic Claude API.

The browser collects the interview transcript and architecture diagram state. At regular intervals, the application sends the relevant interview context to a secure server-side API route.

Claude analyzes the candidate's response and can:

Ask clarifying questions
Challenge weak architectural decisions
Ask about scalability
Explore failure scenarios
Question database and API choices
Provide hints when the candidate appears stuck

The application also includes a diagram critic that looks for important architectural components and potential weaknesses such as missing caching, queues, load balancing, or single points of failure.

Scoring

At the end of the interview, ArchCoach generates a structured scorecard.

The candidate is evaluated from 1–5 across:

Requirements gathering
API and data modeling
Scalability
Trade-off reasoning
Communication

Each score is accompanied by evidence from the interview transcript.

The scorecard also provides the top three areas for improvement and a suggested reference architecture.

Why I Built It

I wanted to create something that demonstrates a practical use of AI rather than simply placing a chatbot inside a website.

The goal was to make AI behave like an engineering interviewer that responds to the candidate's actual reasoning.

This makes the practice experience more dynamic and closer to a real system-design interview.

What I Learned

Building ArchCoach helped me understand how to combine an AI model with structured application logic instead of relying on unstructured model output.

I learned the importance of:

Structured prompts
Schema validation
Server-side API security
Managing conversational context
Designing typed application state
Handling voice input and output
Working with interactive diagrams
Creating reliable AI-generated structured data
Designing useful evaluation criteria

I also learned that AI features work better when the model has clear constraints, structured inputs, and a well-defined output schema.

Challenges

One of the biggest challenges was connecting multiple interactive systems into one workflow.

The application needs to coordinate the interview transcript, voice interaction, whiteboard state, AI responses, timers, scoring, and user interface.

Another challenge was ensuring that the Anthropic API key remains server-side rather than exposing it to the browser.

I addressed this by routing model requests through a secure Next.js API route and validating structured data with Zod.

Future Improvements

Future versions could include:

Persistent user accounts
More system-design problems
Interview difficulty adaptation based on performance
Better diagram understanding using vision models
Team interview mode
More detailed architecture comparisons
Personalized learning plans
Historical performance analytics
More advanced voice interaction

Conclusion

ArchCoach combines AI interviewing, system-design practice, interactive architecture diagrams, and structured feedback into one workflow.

The project was designed to demonstrate how planning-first development and AI-assisted engineering can be combined to build a useful, maintainable application under hackathon constraints.