Smart Interview Simulator (SIS)

A Production-Grade Technical Interview Simulation Platform

Designed to simulate real-world engineering interviews with structured evaluation pipelines, role-based workflows, analytics dashboards, and scalable backend architecture.

Overview

Smart Interview Simulator (SIS) is a full-stack interview preparation platform engineered to replicate the workflow and pressure of modern technical interviews.

Unlike traditional coding platforms that only validate correctness, SIS focuses on the complete interview lifecycle — from interview scheduling and role-based access control to AI-assisted evaluation and performance analytics.

The platform is built with production-oriented architecture principles including:

Modular service-driven backend architecture
Deterministic interview session lifecycle management
JWT authentication + RBAC authorization
Real-time session orchestration
Scalable Prisma ORM data layer
Analytics-driven evaluation pipelines
Clean separation of business logic and infrastructure layers

Core Objectives

Why SIS Exists

Most interview preparation platforms suffer from major limitations:

Static question repositories
No structured evaluation system
Lack of interview workflow simulation
Minimal analytics and feedback loops
Weak scalability and architecture design

SIS solves these gaps by creating a system that behaves closer to real hiring pipelines used in engineering organizations.

Demo Login Credentials

Use the following credentials to explore the platform:

--> FOR ADMIN LOGIN

Email: admin@example.com
Password: Admin@123

--> FOR STUDENT LOGIN

Email: student1@test.com
Password: password1234

Key Features

Student Experience

Technical interview simulation environment
Interview scheduling and session management
AI-assisted feedback generation
Google OAuth 2.0 Integration: Secure social login for streamlined onboarding.
Premium Analytics Dashboard: Advanced data visualization using Recharts and Framer Motion.
Cloud & DevOps Engineering Track: Specialized simulations for infrastructure professionals.
Real-time coding and discussion workflows
Structured evaluation reports

Admin Dashboard

Dynamic question bank management
Interview orchestration and monitoring
Student analytics and scoring insights
Session moderation tools
Access control and user management
Interview report generation
Ban / unban capability for interview access

System Architecture

┌──────────────────────────────┐
│        React Frontend        │
│  React 19 + TypeScript + UI │
└──────────────┬───────────────┘
               │
               ▼
┌──────────────────────────────┐
│        Express API Layer     │
│ Authentication + Routing     │
└──────────────┬───────────────┘
               │
               ▼
┌──────────────────────────────┐
│        Service Layer         │
│ Interview Engine + Logic     │
└──────────────┬───────────────┘
               │
               ▼
┌──────────────────────────────┐
│          Prisma ORM          │
│     Database Abstraction     │
└──────────────┬───────────────┘
               │
               ▼
┌──────────────────────────────┐
│        PostgreSQL DB         │
└──────────────────────────────┘

Interview Lifecycle Engine

The interview engine follows a deterministic state-driven workflow.

IDLE
  ↓
SCHEDULED
  ↓
ACTIVE
  ↓
EVALUATION
  ↓
FEEDBACK_DELIVERED

This architecture enables:

Predictable session transitions
Better observability
Easier debugging
Cleaner scalability patterns
Controlled evaluation orchestration

Evaluation Pipeline

SIS uses a modular scoring architecture to evaluate interview performance.

Evaluation Components

Keyword coverage analysis
Conceptual relevance scoring
Communication clarity assessment
Code structure evaluation
Weighted score aggregation
Feedback synthesis generation

Evaluation logic is isolated from controllers through dedicated service abstractions.

Tech Stack

Frontend

Technology	Purpose
React 19	UI rendering
TypeScript	Type safety
Vite	Build tooling
Tailwind CSS v4	Styling system
Framer Motion	Animations
Recharts	Analytics visualization
Monaco Editor	Code editor integration
React Router v7	Routing
Socket.IO Client	Real-time communication

Backend

Technology	Purpose
Node.js	Runtime environment
Express.js	API framework
TypeScript	Scalable backend development
Prisma ORM	Database abstraction
PostgreSQL	Relational database
JWT	Authentication
BullMQ	Background job queues
Redis	Queue + caching layer
Socket.IO	Real-time communication
Google Generative AI SDK	AI evaluation support

Engineering Highlights

Production-Oriented Design Decisions

Layered clean architecture
Service-driven backend organization
Repository-style database interaction patterns
Modular evaluation engine
Secure JWT-based authentication
Role-Based Access Control (RBAC)
Real-time communication support
Scalable Prisma schema design
Queue-ready infrastructure using BullMQ + Redis
Strong TypeScript typing across frontend and backend

Repository Structure

Smart_Interview_Simulator/
│
├── frontend/
│   ├── src/
│   ├── components/
│   ├── pages/
│   ├── hooks/
│   └── services/
│
├── backend/
│   ├── prisma/
│   ├── src/
│   │   ├── controllers/
│   │   ├── routes/
│   │   ├── middleware/
│   │   ├── services/
│   │   ├── utils/
│   │   └── config/
│
├── docker-compose.yml
├── render.yaml
└── README.md

Local Development Setup

Prerequisites

Ensure the following tools are installed:

Node.js >= 18
MySQL Server
Redis (optional but recommended)
npm or pnpm

Backend Setup

cd backend
npm install

Configure Environment Variables

Create a .env file inside the backend directory.

Example:

DATABASE_URL="postgresql://USER:PASSWORD@localhost:5432/sis"
JWT_SECRET="your_secret"
PORT=5001

Run Prisma Migrations

npx prisma generate
npx prisma migrate dev

Start Backend Server

npm run dev

Backend runs on:

http://localhost:5001

Frontend Setup

cd frontend
npm install
npm run dev

Frontend runs on:

http://localhost:5173

API & Infrastructure Capabilities

Authentication Layer

JWT token authentication
Protected route middleware
RBAC authorization flows
Session persistence

Real-Time Infrastructure

Socket.IO powered communication
Live session synchronization
Real-time interview event handling

Queue Architecture

BullMQ integration support
Redis-backed task orchestration
Scalable async processing model

Future Roadmap

Planned Enhancements

Full LLM-powered interview evaluation
Voice-based mock interviews
WebRTC live interview simulation
AI interviewer personas
Advanced analytics dashboards
Multi-organization support
Event-driven microservice migration
Kubernetes deployment support
Distributed evaluation workers

Deployment

The repository already includes:

docker-compose.yml
render.yaml

This enables easier local containerization and cloud deployment workflows.

Performance & Scalability Considerations

The system architecture is intentionally designed with scalability in mind.

Current Scalability Foundations

Stateless API design
Service isolation
Queue-compatible processing
ORM abstraction layer
Centralized authentication flow
Real-time infrastructure support

These design decisions make SIS suitable for future horizontal scaling and distributed workloads.

Security Considerations

Implemented Security Features

JWT authentication
Password hashing using bcrypt
Protected backend middleware
Role-based authorization
API request validation
Rate limiting support

Author

Manik Tyagi

Full-Stack Developer focused on:

Backend Architecture
System Design
Scalable Web Infrastructure
AI-Integrated Applications
Production-Oriented Engineering

License

This project is intended for:

Educational use
Portfolio showcase
System design learning
Technical interview preparation

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
backend		backend
frontend		frontend
.gitignore		.gitignore
README.md		README.md
docker-compose.yml		docker-compose.yml
render.yaml		render.yaml
verify_system.sh		verify_system.sh

Latest commit

History

Folders and files

Repository files navigation