HirePilot AI is a Lemma-powered Job Mission workflow for technical interview readiness.
The core product insight is:
Evidence Fit is not the same as Interview Readiness.
A candidate may have strong project evidence for a job requirement but still carry interview risk if they cannot explain that evidence clearly under pressure. HirePilot AI separates those two signals and turns interview preparation into a structured workflow.
Hosted Lemma app:
https://hirepilot-ai.apps.lemma.work
Access may require being added to the Lemma pod.
V2.6 — Native Lemma Function Path + Latest Attempt Mode
V2.6 confirms the native Lemma function path for deterministic mock-answer evaluation and stabilizes repeated mock-answer submissions through Latest Attempt Mode.
Completed milestones:
Version 1 — Hosted Lemma MVP
V2.1 — Idempotent Lemma Sync
V2.2 — Expanded Data Model
V2.3 — Mission History Dashboard
V2.4 — Live Job Description Extraction
V2.5 — Candidate Evidence Matching
V2.6 — Native Lemma Function Path + Latest Attempt Mode
The final submission demo focuses on a Backend/Docker Job Mission.
Role: Backend Developer
Company: Acme AI
Extracted requirements: 6
Evidence Fit: 77/100
Interview Risk: High / 77
Execution after mock answer: Lemma Function
Mock answer result: Weak / 42 / High risk
Workflow events: 11
Latest attempt events: 4
The demo proves the core thesis:
Evidence Fit ≠ Interview Readiness
The candidate has strong Docker Compose project evidence, but the weak mock answer exposes high interview risk around Docker networking, service discovery, database hostnames, localhost vs container hostnames, and startup dependencies.
Students and early-career candidates often apply to jobs based on surface-level resume or project matches. They may have relevant projects, but they do not know which requirements they can actually defend in an interview.
Most tools answer:
Does this resume match the job?
HirePilot AI answers:
Can this candidate explain the evidence well enough to pass the interview?
HirePilot AI turns a job description into a persistent Job Mission.
The current workflow is:
Paste Backend/Docker Job Description
→ Extract Requirements
→ Review/Edit Requirements
→ Match Candidate Evidence
→ Review/Edit Evidence Matches
→ Create Job Mission
→ Calculate Evidence Fit
→ Calculate Interview Risk
→ Submit Mock Answer
→ Evaluate Mock Answer through Native Lemma Function path
→ Update Weakness Memory
→ Regenerate Practice Plan
→ Track Mission in Dashboard
→ Sync Schema-Safe Mission Artifacts to Lemma
HirePilot AI separates:
Evidence Fit
from:
Interview Readiness Risk
Example:
A candidate may have Docker Compose evidence in a project, so Evidence Fit is strong. But if the candidate cannot explain internal Docker networking, service discovery, database hostnames, localhost behavior inside containers, or startup dependencies, Interview Risk remains high.
This creates the main HirePilot AI insight:
Evidence Fit ≠ Interview Readiness
The final Backend/Docker demo extracts a focused and believable requirement set:
FastAPI / Python backend APIs — Must-have
SQL database design — Must-have
Docker / Docker Compose — Important
AWS / cloud deployment — Nice-to-have
CI/CD pipelines — Important
Automated testing — Important
The extractor intentionally avoids unsupported React or Kubernetes requirements unless the job description explicitly mentions frontend/UI/JavaScript/TypeScript or Kubernetes/k8s/cluster concepts.
Final Backend/Docker mission state:
Evidence Fit: 77/100
Interview Risk: High
Risk Score: 77/100
Docker evidence: Strong
Docker explanation risk: High
Mock answer verdict: Weak
Mock answer score: 42/100
Mock answer risk: High
This score combination shows the product insight clearly: the candidate has enough evidence to be considered a fit, but still needs targeted practice before interviewing.
✅ Hosted Lemma app
✅ Local development fallback
✅ Job Mission workflow
✅ Live job description extraction
✅ Requirement review/edit flow
✅ Candidate evidence library
✅ Deterministic candidate evidence matching
✅ Evidence match review/edit flow
✅ Evidence Fit scoring
✅ Interview Risk scoring
✅ Native Lemma function for mock-answer evaluation
✅ Hosted Lemma Function execution path
✅ CLI-verified weak/strong answer scoring
✅ Guarded execution adapter
✅ Local deterministic fallback for demo stability
✅ Latest Attempt Mode
✅ Mock answer feedback
✅ Weakness memory update
✅ Adaptive practice plan
✅ Mission history dashboard
✅ Lemma table schemas
✅ Idempotent sync registry
✅ Expanded artifact materialization
✅ Workflow trace
✅ State Inspector
V2.6 adds a native Lemma function for deterministic mock-answer evaluation.
The deployed Lemma function:
hirepilot_evaluate_mock_answer
evaluates a candidate’s answer to a Docker Compose interview question and returns:
score
verdict
risk level
risk score
missing concepts
covered concepts
weakness tags
practice recommendations
The native Lemma function path was validated through Lemma CLI and is also surfaced in the hosted product through the V2.6 execution path.
The frontend uses a guarded execution adapter. If browser auth, SDK runtime, CORS, or workflow constraints prevent direct native execution, HirePilot falls back to the local deterministic evaluator so the demo remains stable.
The function hirepilot_evaluate_mock_answer was validated through Lemma CLI using direct top-level payloads.
| Test Case | Result |
|---|---|
| Weak Docker answer | Weak / 42 / High risk |
| Strong Docker answer | Strong / 88 / Low risk |
The weak answer missed key Docker Compose concepts such as:
internal Docker networking
service discovery by service name
database hostname
localhost vs container hostname
startup dependency handling
The strong answer covered:
internal network behavior
service-name communication
db / PostgreSQL hostname usage
localhost behavior inside containers
health checks
startup dependencies
The hosted frontend uses a guarded execution adapter.
Expected hosted behavior before mock-answer submission:
Execution: Not Evaluated Yet
Function attempted: No
Workflow attempted: No
Latest Attempt Mode: Enabled
Expected hosted behavior after submitting the weak Docker answer:
Execution: Lemma Function
Attempt #1
Function attempted: Yes
Workflow attempted: No
Latest Attempt Mode: Enabled
Mock answer result: Weak / 42 / High risk
If the native function path is unavailable due to browser auth, CORS, SDK runtime, or workflow constraints, the app uses local deterministic fallback. This fallback is intentional and keeps the demo stable.
The native function proof remains visible through:
Native Lemma Function: CLI Verified
Weak Docker Answer → Weak / 42 / High risk
Strong Docker Answer → Strong / 88 / Low risk
V2.6 adds Latest Attempt Mode.
Repeated mock-answer submissions update the current mission with the latest attempt id, attempt number, execution path, feedback, weakness memory, and practice plan instead of creating noisy duplicate attempt history.
Expected clean state:
mock_answers: 1
workflow_events: 11
latest_attempt_events: 4
This keeps the demo clean and makes the workflow trace easier to understand.
HirePilot uses deterministic Candidate Evidence Matching to compare extracted job requirements against a structured candidate evidence library.
After requirements are extracted from a pasted job description, HirePilot compares each requirement against candidate evidence and generates reviewable evidence matches.
Each evidence match includes:
Evidence verdict
Confidence score
Evidence title
Evidence summary
Matched keywords
Risk level
Risk reason
Source label
The user can review and override evidence matches before creating the Job Mission.
This makes the product stronger because it evaluates both sides:
Job Requirements
+
Candidate Evidence
=
Evidence Fit + Interview Risk
The candidate evidence library includes structured project/evidence items. Not every evidence item is used in the final Backend/Docker demo; the matcher selects only evidence relevant to the extracted requirements.
Current evidence items include:
Inventory and Finance API projects
PostgreSQL / SQLAlchemy persistence layer
Inventory System Docker Compose deployment
C++ concurrent key-value store
Project testing and validation workflow
React frontend application work
Cloud deployment evidence gap
Each item includes:
Title
Summary
Skills
Categories
Strength
Interview risk tags
HirePilot AI uses Lemma for:
Hosted app deployment
Pod-based app access
Structured table schemas
Record sync for mission artifacts
Candidate profile records
Job mission records
Job requirement records
Evidence match records
Expanded readiness artifacts
Native Lemma function for mock-answer evaluation
Function CLI execution proof
Guarded execution adapter
Core Lemma tables:
candidate_profiles
job_missions
job_requirements
evidence_matches
mock_answers
workflow_events
Expanded V2.2 tables:
risk_factors
battle_plan_items
weakness_memory
practice_plan_items
mission_snapshots
V2.6 native Lemma function:
hirepilot_evaluate_mock_answer
The app uses a guarded sync path for hosted stability. Rich local workflow/debug artifacts remain visible in the UI and State Inspector even when deferred from frontend cloud sync.
HirePilot AI uses a guarded frontend sync path for hosted stability.
The frontend sync path writes schema-safe mission artifacts to Lemma tables:
candidate_profiles
job_missions
job_requirements
evidence_matches
risk_factors
battle_plan_items
weakness_memory
practice_plan_items
The following artifacts are generated in app state and shown in the State Inspector, but are deferred from frontend cloud sync for hosted stability:
workflow_events
mission_snapshots
mock_answers
workflow_events are deferred from frontend sync to avoid hosted bulk endpoint timeout risk.
mission_snapshots are deferred from frontend sync to avoid hosted schema mismatch risk.
mock_answers are deferred because V2.6 Latest Attempt Mode stores richer evaluation details than the current hosted mock_answers table schema accepts.
The app still preserves these artifacts in:
local mission state
mission history
State Inspector
Workflow Trace
Mock Answer Feedback
Weakness Memory
Practice Plan
Latest Attempt Debug
The stable frontend sync focuses on durable, schema-safe mission artifacts while keeping richer workflow/debug artifacts local-first for demo reliability.
React
Vite
Mantine UI
React Router
Lemma SDK
Lemma CLI
Lemma hosted app deployment
Lemma pod table schemas
Native Lemma function
localStorage fallback
JavaScript deterministic scoring, extraction, and evidence matching
From the app folder:
cd app
npm install
npm run devBuild:
npm run buildEnvironment variables should be stored locally in .env.local.
Do not commit .env.local.
Recommended local development flags:
VITE_ENABLE_LEMMA_AUTH=false
VITE_ENABLE_UPSERT_SYNC=false
VITE_ENABLE_LIVE_JOB_EXTRACTION=true
VITE_ENABLE_LIVE_CANDIDATE_EVIDENCE_MATCHING=true
VITE_ENABLE_LATEST_ATTEMPT_MODE=true
VITE_ENABLE_NATIVE_LEMMA_FUNCTION_PATH=false
VITE_ENABLE_NATIVE_LEMMA_WORKFLOW_PATH=false
Localhost browser calls to Lemma Cloud may be blocked by CORS, so local development uses fallback paths.
Use environment variables at build time.
Recommended stable hosted build shape:
VITE_ENABLE_LEMMA_AUTH=false \
VITE_ENABLE_UPSERT_SYNC=true \
VITE_ENABLE_LIVE_JOB_EXTRACTION=true \
VITE_ENABLE_LIVE_CANDIDATE_EVIDENCE_MATCHING=true \
VITE_ENABLE_LATEST_ATTEMPT_MODE=true \
VITE_ENABLE_NATIVE_LEMMA_FUNCTION_PATH=true \
VITE_ENABLE_NATIVE_LEMMA_WORKFLOW_PATH=false \
VITE_LEMMA_POD_ID=$LEMMA_POD_ID \
VITE_LEMMA_API_URL=https://api.lemma.work \
VITE_LEMMA_AUTH_URL=https://lemma.work/auth \
npm run buildDo not hardcode the pod ID in documentation.
Deploy from the app folder:
lemma app deploy hirepilot-ai . \
--pod "$LEMMA_POD_ID" \
--dist-dir dist \
-yWeak direct test:
lemma function run hirepilot_evaluate_mock_answer \
--pod "$LEMMA_POD_ID" \
--file ./pod/payloads/hirepilot-evaluate-answer-test-payload-direct.json \
--fullStrong direct test:
lemma function run hirepilot_evaluate_mock_answer \
--pod "$LEMMA_POD_ID" \
--file ./pod/payloads/hirepilot-evaluate-answer-strong-test-payload-direct.json \
--fullExpected proof:
Weak direct payload → COMPLETED / Weak / 42 / High
Strong direct payload → COMPLETED / Strong / 88 / Low
Recommended final demo:
1. Open the hosted Lemma app
2. Create a Backend/Docker Job Mission
3. Use the sample backend job description
4. Extract 6 requirements
5. Review the clean requirement set
6. Match candidate evidence
7. Show Docker evidence as Strong but interview risk as High
8. Create Job Mission
9. Show Evidence Fit: 77/100
10. Show Interview Risk: High / 77
11. Show Execution: Not Evaluated Yet before answering
12. Show Native Lemma Function: CLI Verified
13. Submit the weak Docker Compose answer once
14. Show Execution: Lemma Function
15. Show Weak / 42 / High risk
16. Show missing Docker concepts
17. Show Weakness Memory update
18. Show updated Practice Plan
19. Show Workflow Trace with 11 events
20. Show State Inspector counts
21. Sync schema-safe artifacts to Lemma
22. Return to Dashboard
Weak mock answer:
Docker Compose helps run backend, frontend, and database together.
Expected feedback:
Weak / 42 / High risk
Missing concepts:
- Internal Docker Network
- Service Discovery by Service Name
- Database Service Hostname
- Localhost vs Container Hostname
- Startup Dependencies and Health Checks
Requirement extraction is deterministic, not LLM-based.
Candidate evidence matching is deterministic/rule-based, not LLM-based.
Candidate evidence library is currently seeded/static.
Mission history is local-first.
Frontend sync uses local registry idempotency.
workflow_events are deferred from frontend sync.
mission_snapshots are deferred from frontend sync.
mock_answers are deferred from frontend sync.
Native Lemma workflow graph execution is deferred because the native function path already provides enough proof for the demo.
These limitations do not block the final demo because the product flow remains stable and the native Lemma function path is verified.
V2.7 — Resume/Profile Ingestion
V2.8 — Adaptive Practice Engine Expansion
V2.9 — Readiness Analytics
V2.10 — Production Polish
This project is built for the Ship to Get Hired — Gappy AI Hackathon powered by Lemma SDK.
Primary submission assets:
Hosted Lemma app link
GitHub repository link
Short demo video
README and docs
Recommended final demo state:
Clean mission history
One fresh mission
One mock-answer submission
Evidence Source shown as Candidate Evidence Matching
Requirement Source shown as Live Job Description
Native Lemma Function shown as CLI Verified
Execution shown as Lemma Function
Hosted app available through Lemma
Schema-safe sync completed
HirePilot AI is a Lemma-powered Job Mission workflow that proves a candidate can be a strong resume/project fit but still have hidden interview-readiness risk.
It uses structured mission state, deterministic scoring, candidate evidence matching, native Lemma function evaluation proof, weakness memory, adaptive practice planning, workflow trace, State Inspector, and guarded Lemma sync to make interview preparation actionable.