AI-Proctored Assessment Platform

An intelligent online assessment platform combining adaptive testing with AI-powered real-time proctoring.

This end-to-end application brings assessment delivery, candidate identity and environment checks, browser integrity monitoring, computer-vision analysis, evidence capture, risk scoring, and administrative review into one system.

https://shorturl.az/KVXu

Key Features

Adaptive assessment

• Six assessment tracks: AI/ML, data analytics, full-stack development, DevOps, DSA, and aptitude
• Configurable starting difficulty and assessment length
• Performance-driven question selection with persisted adaptive sessions
• Timed exam experience, question navigation, and automatic completion handling
• Candidate skill and assessment reports

AI proctoring

• Live webcam monitoring during an assessment
• YOLO-based detection for missing or multiple people, phones, books, laptops, and additional screens
• MediaPipe face-landmark and iris analysis for look-away monitoring in the browser
• Detection streaks and cooldowns to reduce noisy duplicate alerts
• Evidence image capture for confirmed computer-vision violations

Assessment security

• Fullscreen, tab visibility, focus, keyboard, and browser-event monitoring
• Structured proctoring audit events with severity and risk points
• Authentication and role-based access for candidates and administrators
• Server-side assessment session and integrity-event persistence

Candidate and proctor portals

• Candidate registration and sign-in
• Assessment selection, instructions, and camera/microphone/network system checks
• Exam interface with webcam preview and AI status feedback
• Candidate results, skill reports, and assessment history
• Administrator dashboard with candidate search, assessment summaries, violation history, risk levels, and evidence review

Architecture

flowchart LR
    C[Candidate browser] --> N[Next.js frontend]
    A[Admin / proctor] --> N
    N --> F[FastAPI REST API]
    F --> Auth[JWT authentication]
    F --> Assess[Adaptive assessment engine]
    F --> Audit[Proctoring audit and reports]
    N --> MP[MediaPipe gaze analysis]
    F --> CV[OpenCV + YOLO analysis]
    Auth --> DB[(SQLite)]
    Assess --> DB
    Audit --> DB
    CV --> E[Private evidence storage]
    CV --> Audit

Loading

AI Proctoring Pipeline

Webcam frame
    -> Browser face/iris and attention analysis
    -> Backend object/person detection
    -> Streak and confidence validation
    -> Confirmed violation
    -> Evidence capture and risk event
    -> Admin review dashboard

Browser integrity events such as leaving fullscreen or hiding the tab follow the audit path directly without requiring image inference.

Tech Stack

• Frontend: Next.js 16, React 19, TypeScript, Tailwind CSS, Lucide React, Radix UI, Framer Motion
• Backend: Python, FastAPI, Uvicorn, SQLAlchemy, SQLite, Pydantic, JWT authentication
• AI / computer vision: OpenCV, Ultralytics YOLO, MediaPipe Tasks Vision, NumPy
• Data: Pandas-backed CSV question banks and persisted adaptive-assessment records

Project Structure

.
├── backend/
│   ├── app/
│   │   ├── database/       # SQLite configuration
│   │   ├── models/         # User and assessment persistence models
│   │   ├── routers/        # Authentication, assessment and reporting APIs
│   │   └── services/       # Adaptive, question, auth and vision logic
│   ├── data/questions/     # Versioned assessment question banks
│   ├── requirements.txt
│   └── yolo26n.pt          # Runtime object-detection weights
├── frontend/
│   ├── app/                # Candidate, exam, report and admin routes
│   ├── components/         # Shared UI and proctoring components
│   ├── hooks/              # Browser proctoring orchestration
│   ├── lib/                # Typed API clients
│   └── public/models/      # Browser face-landmark model
├── .env.example
├── .gitignore
└── README.md

Runtime databases, event logs, and webcam evidence are intentionally excluded from source control.

Local Installation

Prerequisites

• Node.js 20 or newer and npm
• Python 3.11 or newer and pip
• A webcam and microphone
• A current Chromium-based browser with camera, microphone, and fullscreen support

1. Configure the backend

From the repository root:

cd backend
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

Create backend/.env using the backend entries in the root .env.example. Generate a strong JWT secret, for example with python -c "import secrets; print(secrets.token_urlsafe(48))", and choose a private administrator password.

Start the API:

uvicorn app.main:app --reload

The API runs at http://127.0.0.1:8000; interactive API documentation is at http://127.0.0.1:8000/docs.

2. Configure the frontend

In another terminal:

cd frontend
npm install

Create frontend/.env.local:

NEXT_PUBLIC_API_URL=http://127.0.0.1:8000

Then start the application:

npm run dev

Open http://localhost:3000.

Environment Variables

Variable	Used by	Purpose
JWT_SECRET_KEY	Backend	Secret used to sign access tokens; minimum 32 characters
JWT_ACCESS_TOKEN_MINUTES	Backend	Access-token lifetime; minimum 5 minutes
DEFAULT_ADMIN_NAME	Backend	Name assigned when creating the initial administrator
DEFAULT_ADMIN_EMAIL	Backend	Email assigned to the initial administrator
DEFAULT_ADMIN_PASSWORD	Backend	Private initial administrator password; minimum 8 characters
VISION_MODEL	Backend	YOLO model path or supported model identifier
VISION_DEVICE	Backend	Inference device, such as cpu
VISION_IMAGE_SIZE	Backend	YOLO inference image size
VISION_CONFIDENCE	Backend	Base object-detection confidence threshold
NEXT_PUBLIC_API_URL	Frontend	Public base URL for the FastAPI service

Usage

1. Start the backend and frontend services.
2. Register or sign in through the candidate portal.
3. Select an assessment track, difficulty, and question count.
4. Complete the browser, camera, microphone, network, and focus checks.
5. Start the assessment; webcam and browser-integrity monitoring begin with the exam.
6. Submit the assessment or allow its completion rules to finish the session.
7. Sign in with a privately configured administrator account to review reports, risk events, and captured evidence.

No public demo credentials are included. Configure your own administrator credentials in backend/.env.

Screenshots

Product screenshots will be added here after a privacy-safe demo dataset is prepared.

Why I Built This

I built this project to combine practical computer vision with a complete assessment product: not just an isolated detection model, but a full-stack workflow that delivers tests, records integrity signals, and turns AI observations into reviewable evidence and risk information.

Privacy & Demo Notice

Webcam access is required for proctoring. Captured evidence is intended to demonstrate assessment-integrity workflows and must not be committed to source control. A production deployment should obtain appropriate consent and use encrypted storage, retention controls, strict authorization, audit logging, and applicable privacy safeguards for personal data.

Future Improvements

• More robust and calibrated gaze estimation across varied devices and lighting
• Encrypted persistent evidence storage with configurable retention policies
• Scalable asynchronous inference and deployment architecture
• Richer risk analytics, reviewer workflows, and automated reports
• Broader automated testing and model-quality evaluation

Repository Metadata

Suggested description: AI-powered online assessment platform with adaptive testing, real-time computer vision proctoring, evidence capture and risk analysis.

Suggested topics: artificial-intelligence, machine-learning, computer-vision, ai-proctoring, online-assessment, fastapi, nextjs, typescript, python, opencv

Author

Sreedev A AI/ML Engineer

• GitHub
• Portfolio
• LinkedIn