completed

Mission Run

Hackathon MVP: Hiring Pipeline Tracker for Recruiting Teams (Next.js)

Build a hiring pipeline tracker for recruiting teams with candidate stages, interview scorecards, AI-generated candidate summaries, hiring bottleneck alerts, and recruiter/admin dashboards.

Created: 14 Jun 2026, 7:44 am

Updated: 14 Jun 2026, 10:28 am

Repository Context

Greenfield Next.js app. Needs polished web UI, route handlers, local persistence first, and clean architecture for future multi-user support.

Constraints

Keep the MVP hackathon-focused. Prioritize candidate flow, interview feedback capture, AI summaries, and strong demo clarity.

Execution Stepper

The mission run has finished. Completed steps remain as a visible execution trace.

✓

Define MVP scope, entities, and demo flow

Completed

✓

Set up Next.js app foundations and UI system

Completed

✓

Design database schema and local persistence layer

Completed

✓

Implement route handlers (API) for core CRUD

Completed

✓

Build Pipeline board (stage columns + drag/drop or move actions)

Completed

✓

Candidate profile page (timeline + stage control + artifacts)

Completed

✓

Interview scorecard capture (rubric + ratings + recommendation)

Completed

✓

AI-generated candidate summary (from scorecards + notes)

Completed

AI Software Execution Operating System

Primary users

Founders, product leads, architects, delivery teams, and AI-native engineering teams that need a system of record between idea and execution.

Problem solved

It transforms mission intelligence into PRDs, technical designs, engineering plans, AI execution packs, architecture maps, risk models, and traceable workflows.

Product Flow Diagram

Hiring pipeline intelligence flow

Recruiter

Moves candidates and reviews pipeline health

Candidate Pipeline

Sourced, screen, onsite, offer, hired/rejected

Scorecards

Structured interview feedback and recommendations

AI Summary

Strengths, risks, next step, model metadata

Architecture Diagram

System components for this idea

Users

Recruiters + hiring managers

Edge

Route 53 / CDN / WAF boundary

Application VPC

Web App

Next.js App Router

API Server

TypeScript

Worker

Mission/document generation jobs

Cache

Saved docs + fast reloads

Data Plane

Primary DB

SQLite via Prisma for the MVP; PostgreSQL/Supabase when multi-user collaboration is added.

Object Storage

Generated docs, exports, artifacts

stagescandidatesinterviewsscorecardsnotesai_summariesalerts

AI + Operations

OpenAI API

PRD, TDD, plan, AI pack

Observability

Logs, risks, decision trail

IAM / Secrets

Server-side keys + access control

Alerts

Execution and risk signals

Cloud Diagram

Deployment-ready shape

ChannelExperienceMiddlewareResources

Browser

User session

Mission UI

Dashboard + document studio

API Routes

Validate + orchestrate

Storage

Missions + cached docs

AI Client

Codex / external tools

AI Pack

Portable execution context

Doc Engine

Timeout + local fallback

OpenAI

Optional enrichment

Security posture

Keep API keys server-side, validate payloads, and preserve audit logs.

3 risk signals

Risks become visible before execution moves to tools.

Mission Document Studio

Export mission intelligence

Turn the mission into production-ready documents for executives, engineers, delivery teams, and external AI execution tools.

Technical Design Document

Loaded from local mission memory · 6/14/2026, 10:28:13 AM

# Technical Design Document: Hackathon MVP: Hiring Pipeline Tracker for Recruiting Teams (Next.js)

## System Overview
The system converts mission context into structured execution intelligence: tasks, artifacts, risks, decisions, diagrams, and exportable documents.

## Architecture Decisions
- Use Next.js App Router because it supports fast MVP execution and clear handoff.
- Use TypeScript because it supports fast MVP execution and clear handoff.
- Use Tailwind CSS because it supports fast MVP execution and clear handoff.
- Use Route Handlers because it supports fast MVP execution and clear handoff.
- Use Prisma ORM because it supports fast MVP execution and clear handoff.
- Use SQLite for MVP persistence because it supports fast MVP execution and clear handoff.
- Use OpenAI API for AI summaries and document intelligence because it supports fast MVP execution and clear handoff.
- Use Zod for request validation because it supports fast MVP execution and clear handoff.

## Component Breakdown
- Dashboard analytics
- Mission detail command center
- Document Studio
- Traceability Map
- Decision Log
- Mission Memory

## Data Flow
Idea -> Mission plan -> Task execution trace -> Artifacts/risks/summary -> Documents/diagrams/AI execution pack.

## APIs
- POST /api/missions
- POST /api/missions/:id/start
- POST /api/missions/:id/stop
- POST /api/missions/:id/documents
- POST /api/missions/:id/duplicate

## Integrations
- OpenAI API for planning and document intelligence
- Local persistence for hackathon reliability

## Database Design
Recommended database: SQLite via Prisma for the MVP; PostgreSQL/Supabase when multi-user collaboration is added.

Tables:
- stages
- candidates
- interviews
- scorecards
- notes
- ai_summaries
- alerts

## Security Considerations
- Keep API keys in .env.local only
- Do not expose provider errors in the UI
- Validate request payloads
- Preserve execution logs for auditability

## Scalability Considerations
- Move local persistence to PostgreSQL/Supabase
- Cache generated documents
- Add background jobs for long-running generation
- Add org/user scoping

## Deployment Strategy
Deploy as a Next.js app with server-side environment variables and persistent storage configured per environment.

Traceability Map

Why every task exists

This replaces vague “AI said so” planning. Each path shows which goal, requirement, task, architecture choice, or risk explains the work.

goal

Build a hiring pipeline tracker for recruiting teams with candidate stages, interview scorecards, AI-generated candidate summaries, hiring bottleneck alerts, and recruiter/admin dashboards.

requirement

Define MVP scope, entities, and demo flow

task

Define MVP scope, entities, and demo flow

requirement

Set up Next.js app foundations and UI system

task

Set up Next.js app foundations and UI system

requirement

Design database schema and local persistence layer

task

Design database schema and local persistence layer

requirement

Implement route handlers (API) for core CRUD

task

Implement route handlers (API) for core CRUD

requirement

Build Pipeline board (stage columns + drag/drop or move actions)

task

Build Pipeline board (stage columns + drag/drop or move actions)

requirement

Candidate profile page (timeline + stage control + artifacts)

task

Candidate profile page (timeline + stage control + artifacts)

requirement

Interview scorecard capture (rubric + ratings + recommendation)

Trace paths

Kept because traceability is the product moat; renamed from relationships for clarity.

Build a hiring pipeline tracker for recruiting teams with candidate stages, interview scorecards, AI-generated candidate summaries, hiring bottleneck alerts, and recruiter/admin dashboards.drivesDefine MVP scope, entities, and demo flow

Define MVP scope, entities, and demo flowsatisfied byDefine MVP scope, entities, and demo flow

Set up Next.js app foundations and UI systemsatisfied bySet up Next.js app foundations and UI system

Define MVP scope, entities, and demo flowunblocksSet up Next.js app foundations and UI system

Design database schema and local persistence layersatisfied byDesign database schema and local persistence layer

Define MVP scope, entities, and demo flowunblocksDesign database schema and local persistence layer

Implement route handlers (API) for core CRUDsatisfied byImplement route handlers (API) for core CRUD

Mission Decision Log

Explain the important choices

Use Mission Control as the documentation system of record

The mission needs traceable planning artifacts before execution moves into external tools.

Tradeoffs

Improves clarity and handoff quality, but requires users to maintain mission context.

Alternatives

Unstructured chat logs, standalone docs, tickets, or ad hoc planning notes.

Mission Memory

Reuse organizational knowledge

Compare MissionsPlanned capability, not shown as an executable action yet. Current executable memory action is duplicate.

Mission Steps

Task Timeline

8 tasks

Task 1

Define MVP scope, entities, and demo flow

completed

Lock the hackathon MVP requirements and the demo storyline. Define entities and minimal fields: Candidate, Stage, Interview, Scorecard (rubric + ratings), Note, AISummary, Alert. Decide stage list (e.g., Sourced, Screen, Onsite, Offer, Hired, Rejected) and the key user journeys: add candidate, advance stage, add interview + scorecard, generate summary, view bottleneck alerts, view recruiter/admin dashboards. Document non-goals (auth, external ATS integrations).

Owner: plannerDependencies: 0

Completed: MVP scope defined (pipeline board, candidate profile+timeline, interviews+scorecards, AI summary w/ mock fallback, alerts + recruiter/admin dashboards); entities + stages set; demo flow outlined.

Task 2

Set up Next.js app foundations and UI system

completed

Initialize Next.js (App Router), TypeScript, linting/formatting, and a component library (e.g., shadcn/ui + Tailwind). Establish layout shell, navigation (Pipeline, Candidates, Dashboards, Admin), empty states, loading states, and consistent styling tokens for a polished demo.

Owner: builderDependencies: 1

Planned: Next.js App Router + TS; Tailwind + shadcn/ui; react-hook-form + zod; app shell routes (/pipeline, /candidates/[id], /dashboards, /admin) and core UI components/states.

Task 3

Design database schema and local persistence layer

completed

Implement local persistence using SQLite with Prisma (or equivalent). Create schemas for Candidate (name, email, role, source, currentStageId, tags), Stage (name, order), Interview (candidateId, type, date), Scorecard (interviewId, interviewerName, rubric JSON, overallRecommendation, notes), AISummary (candidateId, summaryText, strengths, risks, recommendedNextStep, model, createdAt), Alert (type, entityId, severity, message, status, createdAt). Add a lightweight repository/service layer to isolate persistence for future multi-user support.

Owner: builderDependencies: 1

Planned: SQLite + Prisma schema for Candidate/Stage/Interview/Scorecard/Note/AISummary/Alert; repo/service layering (Pipeline/Dashboard/Alert/AI Summary); seed stages + optional demo candidates.

Task 4

Implement route handlers (API) for core CRUD

completed

Create Next.js route handlers for Candidates, Stages, Interviews, Scorecards, AISummaries, and Alerts. Support: list/create/update candidate; advance stage; add interview; submit scorecard; request AI summary; fetch dashboards data. Validate inputs (zod), return typed responses, and structure endpoints to be compatible with future auth (accept org/user headers but stub them).

Owner: builderDependencies: 1

Planned: Route handlers with zod validation + typed responses for candidates CRUD/advance/timeline, stages, interviews+scorecards, AI summary generate/get, alerts list/update, dashboards recruiter/admin; accept x-org-id/x-user-id headers (no enforcement).

Task 5

Build Pipeline board (stage columns + drag/drop or move actions)

completed

Create the primary demo surface: a pipeline view grouped by stages showing candidate cards with key info (name, role, age-in-stage, last activity). Implement moving candidates between stages via drag/drop or explicit “Move to…” action. Ensure updates persist and UI is responsive with optimistic updates where safe.

Owner: builderDependencies: 2

Planned: Pipeline board grouped by Stage.order; candidate cards show name/role/tags/age-in-stage/last activity; actions include open, move-to-stage, quick reject; optimistic stage moves with rollback on error.

Task 6

Candidate profile page (timeline + stage control + artifacts)

completed

Build candidate detail view with: current stage, quick actions (advance/reject), activity timeline (interviews, scorecards, AI summary), and tabs/sections for Notes, Scorecards, and Summary. This page should be the anchor for the demo after selecting a candidate from the pipeline.

Owner: builderDependencies: 3

Planned: Candidate profile layout with header+stage control, quick actions, timeline, tabs (Notes/Scorecards/Summary); timeline includes stage change, interview created, scorecard, note, AI summary.

Task 7

Interview scorecard capture (rubric + ratings + recommendation)

completed

Implement scorecard UI that recruiters/interviewers can fill quickly: rubric categories (e.g., Communication, Problem Solving, Role Fit) with 1–5 ratings, freeform notes, and overall recommendation (Strong Yes/Yes/No/Strong No). Store as structured data and render a summary view with averages and highlights on the candidate profile.

Owner: builderDependencies: 2

Planned: Scorecard form with default rubric (Communication/Problem Solving/Role Fit), 1-5 ratings, recommendation (Strong Yes/Yes/No/Strong No), notes; profile shows aggregates + expandable scorecards.

Task 8

AI-generated candidate summary (from scorecards + notes)

completed

Add an AI summary generator route handler that composes a prompt using candidate info + aggregated scorecard data + notes, then calls an LLM (configurable provider via env). Persist the generated summary and show it on the candidate page with a clear “Generate/Regenerate Summary” button, timestamps, and model metadata. Include a safe fallback for demo (mock summary) if API key is missing.

Owner: builderDependencies: 2

Planned: AI summary service using provider env vars with deterministic mock fallback; inputs from candidate basics/stage/rubric averages/notes; persist generations and show latest with model+timestamp; regenerate supported.

Audit Trail

Execution Log

18 logs

Mission plan generated successfully.

success

14 Jun 2026, 7:44 am

Mission defined: hackathon MVP hiring pipeline tracker in Next.js with pipeline stages, scorecards, AI summaries, alerts, and dashboards.

info

14 Jun 2026, 7:47 am

MVP scope, entities, and demo storyline finalized with explicit non-goals (no auth/integrations).

success

14 Jun 2026, 7:47 am

Next.js App Router foundation established with Tailwind + shadcn/ui, navigation, and resilient UI states.

success

14 Jun 2026, 7:47 am

SQLite + Prisma persistence designed with repo/service boundaries and demo seed data concept.

success

14 Jun 2026, 7:47 am

Core API route handlers specified/implemented with zod validation and consistent response envelopes.

success

14 Jun 2026, 7:47 am

Pipeline board, candidate profile hub, scorecard capture, and AI summary generation delivered end-to-end with demo-safe mock AI fallback.

success

14 Jun 2026, 7:47 am

Known limitations: no auth/multi-user isolation; alerts may require manual refresh; rubric stored as JSON (MVP tradeoff).

warning

14 Jun 2026, 7:47 am

Locked MVP around pipeline flow: stage movement, interview scorecards, AI summaries, and alerts/dashboards.

info

14 Jun 2026, 7:51 am

Defined minimal entities and fields to support demo clarity while keeping schema extensible for multi-user later.

info

14 Jun 2026, 7:51 am

Chose explicit move actions over drag/drop to reduce integration risk and increase demo reliability.

success

14 Jun 2026, 7:51 am

Specified alert rules for bottlenecks/stale candidates to create visible value in dashboards.

info

14 Jun 2026, 7:51 am

Prepared implementation plan for Next.js App Router, shadcn/ui + Tailwind, and Prisma SQLite persistence.

info

14 Jun 2026, 7:51 am

Outlined repository/service layering to isolate DB and support future org/user scoping.

info

14 Jun 2026, 7:51 am

Planned route handler surface with zod validation and typed responses; included auth-compatible headers as stubs.

info

14 Jun 2026, 7:51 am

Defined AI summary generator contract with safe mock fallback for offline demo environments.

success

14 Jun 2026, 7:51 am

Risk: age-in-stage accuracy could benefit from stageChangedAt; MVP can approximate using updatedAt updated on stage moves.

warning

14 Jun 2026, 7:51 am

Produced MVP scope + demo storyline, schema plan, API plan, UI plan, and alert rules aligned to tasks 0-7.

success

14 Jun 2026, 7:51 am

Mission Outputs

Artifacts

11 artifacts

Mission Plan

plan

Build a greenfield Next.js MVP that clearly demos the end-to-end candidate flow: create candidates, move them across stages, capture interview scorecards, generate AI candidate summaries, and surface bottleneck alerts—wrapped in polished recruiter/admin dashboards. Use local persistence first (SQLite via Prisma or equivalent) with an architecture that anticipates future multi-user support (org/users/roles) without implementing full auth. Emphasize a crisp demo narrative: “See pipeline, click candidate, add feedback, generate summary, watch alerts update.” Keep scope tight by limiting integrations (no calendar, no email) and focusing on reliable CRUD, clear UI, and a few high-value AI/alert features.

MVP Scope & Demo Flow

summary

In-scope: pipeline board by stages; create/edit candidates; move/advance/reject; candidate profile timeline; interview creation; scorecard capture + recommendation; AI summary generation/regeneration with mock fallback; bottleneck alerts (age-in-stage, no recent activity) + basic dashboards; admin-lite stage seeding and health stats. Non-goals: auth, ATS/email/calendar integrations, real-time collaboration, advanced analytics, file uploads.

Data Model (Minimal Entities)

analysis

Entities: Stage(id,name,order); Candidate(id,name,email,role,source,tags[],currentStageId,stageEnteredAt,lastActivityAt,createdAt,updatedAt); Interview(id,candidateId,type,date,createdAt); Scorecard(id,interviewId,interviewerName,rubricJson,overallRecommendation,notes,createdAt); Note(id,candidateId,authorName,text,createdAt); AISummary(id,candidateId,summaryText,strengths[],risks[],recommendedNextStep,model,createdAt); Alert(id,type,entityId,severity,message,status,createdAt).

Architecture & Tech Choices

execution

Next.js App Router + Route Handlers; SQLite + Prisma; repo/service layer (PipelineService, DashboardService, AlertingService) to isolate DB and enable future org/user scoping; shadcn/ui + Tailwind; zod validation; pluggable AI provider via env with mock fallback.

API Surface (Core Endpoints)

execution

Stages: GET /api/stages, POST /api/stages/seed. Candidates: GET/POST /api/candidates, GET/PATCH /api/candidates/[id], POST /api/candidates/[id]/move, POST /api/candidates/[id]/notes, POST /api/candidates/[id]/interviews, POST /api/candidates/[id]/ai-summary. Interviews: POST /api/interviews/[id]/scorecards. Alerts: GET /api/alerts, POST /api/alerts/refresh. Dashboards: GET /api/dashboards/overview. Conventions: zod validation, {data,error} envelope, optional x-org-id/x-user-id headers.

Known Limitations & MVP Tradeoffs

review

No authentication or multi-user isolation (headers stubbed). Alerts are MVP-simple and may rely on manual refresh for demo determinism. Rubric stored as JSON for flexibility; can normalize later. Drag/drop avoided in favor of deterministic move actions.

Mission definition (MVP objective, constraints, and demo focus)

analysis

Objective: hiring pipeline tracker for recruiting teams (stages, scorecards, AI summaries, bottleneck alerts, recruiter/admin dashboards). Constraints: hackathon MVP, prioritize candidate flow + feedback capture + AI summaries + demo clarity; no auth, no external ATS integrations. Greenfield Next.js App Router app with polished UI, local persistence first, clean architecture for future multi-user.

Project structure + UI plan

execution

Planned structure: app/(shell)/layout.tsx; app/pipeline; app/candidates/[id]; app/dashboards; app/admin; app/api/* route handlers; lib/db/prisma.ts; lib/repositories/*; lib/services/*; lib/validation/*; components/*. Navigation: Pipeline, Candidates, Dashboards, Admin. Candidate card fields: Name, Role, Tags, Age in stage, Last activity. Profile sections: Header+stage control, Timeline, Notes, Scorecards, AI Summary. Empty/loading states and default rubric (Communication, Problem Solving, Role Fit).

Data model + persistence architecture

analysis

Entities: Candidate (currentStageId, tags, lastActivityAt), Stage (order), Interview, Scorecard (rubric JSON, overallRecommendation), Note, AISummary (strengths/risks arrays, recommendedNextStep, model), Alert (BOTTLENECK/STALE_CANDIDATE; severity/status). Persistence: SQLite + Prisma. Architecture: repositories per entity; services for pipeline stage moves + computed fields, dashboards aggregations, alert rules/lifecycle, AI summary provider abstraction + mock fallback. Seed: 6 stages and optional 6–10 demo candidates.

API surface plan (route handlers)

execution

Candidates: GET /api/candidates?stageId=&q=; POST /api/candidates; GET/PATCH /api/candidates/:id; POST /api/candidates/:id/advance (toStageId); POST /api/candidates/:id/notes; GET /api/candidates/:id/timeline. Stages: GET /api/stages; POST /api/stages; PATCH /api/stages/:id. Interviews/Scorecards: POST/GET /api/candidates/:id/interviews; POST/GET /api/interviews/:id/scorecards. AI Summary: POST /api/candidates/:id/ai-summary; GET /api/candidates/:id/ai-summary. Alerts/Dashboards: GET /api/alerts; PATCH /api/alerts/:id; GET /api/dashboards/recruiter; GET /api/dashboards/admin. Validation via zod; typed responses; accept optional x-org-id/x-user-id headers (no enforcement).

Demo storyline + alert rules

summary

Demo: pipeline board grouped by stages; add candidate; move Sourced→Screen with optimistic UI; candidate profile add interview + scorecard; generate AI summary (show model + timestamp, regenerate); return to pipeline to show bottleneck alert; open dashboards (recruiter: pipeline health + pending feedback; admin: stage conversion + bottlenecks). Alert rules MVP: BOTTLENECK if stage has >=3 candidates age-in-stage >7 days (severity increases with count); STALE_CANDIDATE if any candidate age-in-stage >10 days.

Final Summary

Mission intelligence cockpit

A compact command-center view of what was learned, what is risky, and what should happen next.

Ready for handoff

Risks

Next Steps

Stack Items

Tables

Outcome

Planning package completed for hackathon MVP (tasks 0–7): scope, entities, schema, API surface, UI plan, alert rules, and demo flow; implementation not executed yet.

Risk Radar

Risks and mitigations

Age-in-stage may be inaccurate if derived from updatedAt; consider adding stageChangedAt later.
AI summary demo depends on provider config; ensure deterministic mock fallback is implemented and clearly labeled.
No auth means all admin-ish endpoints are open; keep deployment/demo environment controlled.

Execution Path

Recommended next steps

Initialize Next.js App Router project with Tailwind + shadcn/ui and implement app shell/navigation.
Add Prisma SQLite schema + migrations and seed stages + demo candidates.
Implement route handlers with zod validation and repository/service layering.
Build Pipeline board and Candidate profile pages, then add scorecards, AI summary generation, alerts, and dashboards.
Run through the demo storyline end-to-end and tune empty/loading states for clarity.

Architecture

Technical foundation

Tech stack

Next.js App Router
TypeScript
Tailwind CSS
Route Handlers
Prisma ORM
SQLite for MVP persistence
OpenAI API for AI summaries and document intelligence
Zod for request validation

Database

SQLite via Prisma for the MVP; PostgreSQL/Supabase when multi-user collaboration is added.

Tables

stages
candidates
interviews
scorecards
notes
ai_summaries
alerts

Project Shape

Suggested file structure

src/app/(dashboard)/pipeline/page.tsx
src/app/candidates/[id]/page.tsx
src/app/api/candidates/route.ts
src/app/api/candidates/[id]/move/route.ts
src/app/api/candidates/[id]/ai-summary/route.ts
src/lib/services/pipeline-service.ts
src/lib/services/alerting-service.ts
src/lib/services/ai-summary-service.ts
prisma/schema.prisma
prisma/seed.ts

Operating Model

Best practices and handoff path

Best practices

Keep AI provider calls behind server-side route handlers.
Use deterministic mock responses for demos when API keys are missing.
Validate all mutation endpoints with zod.
Track stageEnteredAt separately from updatedAt for accurate bottleneck alerts.
Keep domain logic in services so UI and API routes stay thin.

How to use this context

Use the PRD to align product scope and target users.
Use the technical design to implement architecture and data flow.
Use the engineering plan to create sprint tickets.
Use the AI execution pack as context for Codex or another execution tool.
Use risks and decision log as review gates before implementation.