AI-Native Interview Intelligence · Evidence-Driven · Built in Go

Interview scoring that rewrites the past when it learns more.

A local-first interview intelligence platform that evaluates engineering candidates on accumulating evidence, not keywords. Every score traces to specific answers — and a later answer that reveals deeper understanding retroactively lifts the confidence of earlier, shorthand ones. Runs fully local on Ollama; switches to Anthropic Claude with a config flag.

Evidence ledger Retroactive re-scoring Multi-evaluator panel Behavioral HR rounds Measurable-only signals Dual backend · Ollama / Claude
Dharmendra Yadav
Sr. Lead Engineer / Engineering Manager · Agentic AI Architect · Team Leadership & Delivery · AI-Augmented Product Engineering
Go
stdlib-only backend, no framework
17
cohesive engine packages
12
structured design phases
Local
Ollama default · Claude optional
What it is

An interview engine that defends every number it produces

Most automated screening collapses a candidate into keyword overlap. rejected.ai instead runs a conversation, extracts concept-linked evidence from each answer, and recomputes confidence over the entire ledger after every turn — so the assessment is explainable, self-correcting, and honest about what it can and cannot measure.

🧾

Evidence over keywords

Each answer yields positive/negative evidence tied to specific competencies. The evidence ledger is the source of truth — every score cites the turns that justify it.

⏪

Retroactive re-scoring

Confidence is never frozen. When a later answer reinterprets an earlier shorthand one, the earlier evidence is revised — with the revision logged for replay.

🌡️

Three confidence lenses

Every competency is scored cool (skeptical), normal (balanced), and hot (generous), so a reader sees the range of defensible interpretations, not a single opaque verdict.

👥

Multi-evaluator panel

An Architect, EM, Staff+, Operator, ATS, Comms, and AI-Native persona each assess independently — surfacing where reasonable evaluators would disagree.

🤝

Behavioral HR rounds

Dedicated evaluations for soft skills like conflict resolution, mentoring, and alignment. Adapts scores and coaching recommendations specifically for leadership indicators.

📏

Measurable, never inferred

Audio and video produce only counted signals — pace, fillers, engagement, attention. The system deliberately refuses to infer honesty, intelligence, or personality.

The defining behavior

The deferred evidence loop

Each turn's answer is recorded with low latency during the live interview. When generating the report, a background thread replays the session, extracting evidence and rescoring confidence turn-by-turn. Because the whole history is re-evaluated sequentially, re-scoring earlier answers in light of later ones is structural — not a bolt-on.

Questions Upfront → Direct Answer Saving → Deferred Evaluation Loop → Evidence Extraction → Confidence Recompute

…repeated sequentially per turn, with a confidence snapshot captured each time for retroactive re-scoring & replay.

rejected.ai data flow: JD and resume build capability graphs, which pre-generate questions; the live candidate answers are saved directly to MongoDB; when generating the report, a background thread replays the turns sequentially, running evidence extraction and confidence rescoring over the entire ledger, writing retroactive scoring revisions and per-turn snapshots, before outputting the cited report.
End-to-end data flow — setup generates questions, the live runner persists answers, and the deferred background engine runs the confidence recompute sequentially over the ledger.

Why it self-corrects

Confidence isn't accumulated incrementally — it's recomputed from scratch over the full evidence ledger on every turn. That makes retroactive re-scoring a property of the design, so a terse early "duplicate handling" can be lifted once a later answer explains idempotency and exactly-once semantics.

Why it's explainable

Every competency score, strongest signal, risk, and the final hiring recommendation carries citations to the exact turns behind it. The report includes score-evolution sparklines and a revision log — you can audit how a number moved and why.

Advanced Feature

Behavioral Assessment & HR Rounds

Evaluating technical skills is only half the battle. rejected.ai includes a first-class HR Round module specifically engineered to map, score, and cite behavioral traits, communication clarity, and leadership capabilities.

Adaptability

Dynamic Soft Skills Graph

Swaps out technical compiler/system gaps for soft-skill expectations. Measures indicators such as peer alignment, data-driven conflict resolution, and structured mentoring.

Evaluation

Engineering Manager Lens

The evaluator panel leverages a specialized Engineering Manager persona focused on team integration, growth action planning, and seniority gap assessments.

Growth

Behavioral Coaching Guide

Generates tailored mock coaching items detailing growth action plans, study paths, and communication coaching depending on high or low score evaluations.

Domain Type Representation in Go (internal/domain/interview.go)
type Interview struct {
    ID                 bson.ObjectID `bson:"_id"`
    CandidateProfileID bson.ObjectID `bson:"candidate_profile_id"`
    Level              string        `bson:"level"`        // e.g., "Staff Engineer"
    Type               string        `bson:"type"`         // "System Design", "Technical Screening", "HR Round"
    RigorPercent       int           `bson:"rigor_percent"`
    Competencies       []string      `bson:"competencies"` // behavioral or technical competencies
    Status             Status        `bson:"status"`
}
How it's built

A layered Go engine, one concern per package

Seventeen small, single-responsibility packages behind a stdlib net/http router. LLM generation, embeddings, and the database all sit behind interfaces, so backends swap by config rather than code change.

PackageResponsibility
documentsJD / resume ingestion — PDF/DOCX/TXT extraction + LLM structuring
capabilityCandidate, target, and gap capability graphs
interviewSession orchestration, dynamic question generation, memory
evidenceConcept-linked evidence extraction into the ledger
confidenceCore: recompute over the full ledger + retroactive re-scoring
assumptionsPer-answer assumptions + clarification-vs-deflection
evaluatorsPersona panel — Architect / EM / Staff+ / Operator / ATS / Comms / AI-Native
risk · recommendationRisk categorization + explainable, evidence-cited hire decision
reportOrchestrates scores + personas + signals + risk + recommendation
mediaMeasurable-only audio & video signals (pluggable engines)
learningDeterministic cross-interview competency trends
llm · store · config · apiBackend interfaces, MongoDB, config, HTTP router

Stack

● Go 1.26 ● net/http ServeMux ● MongoDB ● Ollama (local LLM) ● Anthropic Claude ● nomic-embed-text ● Next.js (App Router) ● Pluggable whisper.cpp
Setup & Installation

Run the platform locally

Get the complete Go backend and Next.js frontend running on your machine in a few steps.

1

Prerequisites

Make sure you have the following installed and running locally:

Go 1.26+ Node.js 20+ MongoDB (port 27017) Ollama (port 11434)

Pull the required Ollama models for local inference & embeddings:

$ ollama pull gemma4:e4b
$ ollama pull nomic-embed-text
2

Configuration

Copy the configuration file template and edit variables if necessary:

$ cp config.example.json config.json
3

Run Go API Backend

Compile and start the HTTP server. It will bind to http://localhost:8080:

$ go build -o bin/server ./cmd/server
$ ./bin/server
4

Run Next.js Frontend UI

Install Node packages and launch the Next.js development server on http://localhost:3000:

$ cd web
$ npm install
$ npm run dev
5

Populate Database with Mock Data

Run the insert helper script to automatically populate MongoDB with dummy interview rounds. This includes the new Sarah Connor HR behavioral round:

$ go build -o bin/insert_dummy ./cmd/insert_dummy/main.go
$ ./bin/insert_dummy

Once complete, refresh `http://localhost:3000` to review the records, trace turn histories, and inspect generated hiring panels.

What this project demonstrates

Portfolio Engineering Skills

rejected.ai was scoped, architected, and built end-to-end as a single coherent system. It maps directly to how I work as a leader and architect.

Agentic AI Architect

Reasoning systems that stay explainable

  • An evidence-ledger architecture where every LLM output is grounded and citable
  • Confidence recomputation enabling retroactive, consistent re-scoring
  • Backend-agnostic LLM/embedding interfaces — local Ollama or hosted Claude
  • Robust structured-output handling for smaller local models (JSON repair + retry)
System & Software Design

Architecture that ages well

  • 17 single-responsibility packages, dependency-free domain core, no import cycles
  • stdlib-only HTTP layer — deliberate avoidance of unnecessary frameworks
  • Idempotent generation/persistence; one consistent "everything for one interview" access pattern
  • Pluggable engine seams (transcription, video detection) with graceful capability fallbacks
Sr. Lead Engineering / Delivery

Shipping in disciplined increments

  • Delivered in 12 sequenced phases, each verified before the next began
  • Tested pure logic separately from I/O; build + vet + tests green at every step
  • Documentation as a deliverable — architecture, API, and format specs written down, not left in chat
AI-Augmented Product Engineering

Judgement about what AI should and shouldn't do

  • A product stance encoded in code: measure what's countable, refuse to infer character
  • Multi-perspective evaluation that mirrors how real hiring panels actually disagree
  • Deterministic where determinism is honest (trends), generative where it adds value (evidence)
  • A full-stack delivery — Go engine, REST API, and a Next.js report/replay UI

Dig into the engineering

Full Go source, the evidence/confidence core, the measurable-signal design, per-phase docs, and a Next.js report UI all live in the repository.