Product

Technical interviews that produce evidence

Minute 24 of a live session: the candidate finds the performance bug we planted. Follow that session end to end – what they see, what the interviewer sees, and how it becomes a number you can defend.

Explore a sample report Or run your first interview →

The loop

One candidate, brief to report

You pick a format for the role, or paste the job description and let the platform assemble one. Here is how it works: the candidate books a slot, reads their prep brief, and joins a session that is exactly the same for every applicant.

BriefSkills become questions; questions become a format with time budgets and weights.

ScheduleOne signed link. The candidate picks a slot from live interviewer availability.

SessionA structured live session in our browser IDE – same questions, same rubric, every time.

ReportYour team receives a scored report with supporting evidence the same day.

Our interviewers or yours – the platform works the same either way. Every number in that report was computed from things that actually happened in the session. The next two layers are how they get captured.

Sample interview report

Alex Chen

Senior React Engineer · 18 Jun 2026

4.2/5

Strong Hire

Cohort percentile

P88

Skill breakdown

Component Design92%

Performance Optimization88%

State Management95%

Testing & Debugging62%

QuestionRatingHelp

Optimize a slow-rendering data grid4.5Minimal

Build a real-time dashboard component3.8Minimal

Refactor a context-heavy component tree4.3Minimal

Overall notes

Strong React fundamentals. Identified re-render issues immediately and applied the right performance patterns. The dashboard implementation was solid but could have used Suspense more effectively. Explained the debugging process clearly.

Explore a representative sample report ↗

The live session

Two screens, one session

The candidate gets a browser IDE with the call alongside: no installs, no lockdown spyware, code that actually runs. The interviewer gets a teleprompter – the script, follow-ups ranked by how much they give away, and the rubric ticked as things happen. The score assembles from observations made in the moment, not recollections written up after.

✓We track when candidates need help: three levels of assistance, each with a clear, defined effect on the final score.

✓Integrity flags and notes recorded live, timestamped.

✓Every keystroke journaled. You can replay how they think.

That's everything the interviewer catches live. Two more parts of the platform, ones they never see, do the rest of the work.

Senior React Engineer: In progress2 in call

CodeTypeScript

▶ Run

Saved

function useVisibleRows(rows: Row[], scrollTop: number) {

const start = Math.floor(scrollTop / ROW_HEIGHT);

const end = Math.min(rows.length, start + VISIBLE + OVERSCAN);

return useMemo(() => rows.slice(start, end), [rows, start, end]);

}

export function VirtualizedGrid({ rows }: GridProps) {

const [scrollTop, setScrollTop] = useState(0);

const visible = useVisibleRows(rows, scrollTop);Alex Chen

return (

<div onScroll={(e) => setScrollTop(e.currentTarget.scrollTop)}>

{visible.map((row) => <Row key={row.id} {...row} />)}

</div>

);

}

Interview call⠿

SMSarah MillerYou

Run outputexit 0 · 412 ms

✓ virtualization: renders 34 / 10,000 rows

p95 frame 4.1 ms (was 87 ms)

The code runs in the candidate's dedicated microVM, with no local setup.

A browser IDE with the call alongside. Nothing to install, nothing watching them but a person.

Sit in the interviewer's chair – the sandbox is the real teleprompter and rubric on a fake candidate ↗

The engine room

Every candidate gets a real dev environment

Every session boots its own Firecracker microVM – the isolation technology behind AWS Lambda – with its own kernel, its own filesystem, and toolchains for all major languages and frameworks. Ready in well under a second, offline by default, destroyed when the session ends. Candidates get a machine that behaves realistically; you get isolation a shared container can't offer.

✓Single-file mode for convenience or a full-blown project mode with live preview (e.g. React and React Native).

✓Code runs in 2s cold, ~50ms with a warm VM. Iteration feels local.

✓The keystroke journal is timed and attributed – playback rebuilds the code at any moment, with every pause and every paste.

Session VM · Firecracker microVMvm-a3f…82c

Booted for one candidate – nobody else ever touches it.

jailer · chroot + cgroupst+0

Every VM is wrapped in Firecracker's jailer: own chroot, own cgroups, dropped privileges. Candidate code sits two boundaries from the host – guest kernel, then KVM.

kernel 6.1 → userspace~⅛ s *

guest agent ready< 1 s

scratch disk · 2 GB ext4 → /workcreated in ms

toolchains preinstalledpy · node · ts · go · java · c#

run #1 · perf harnessexit 0 · 412 ms

run #2exit 0 · 52 ms

networkoffline

Single-file sessions run with zero egress. Project mode reaches only an allowlisted package proxy – rate-capped and logged, never an open pipe.

session endvm destroyed · disk wiped

* Firecracker's kernel-to-userspace figure. The execution box holds zero platform credentials – an escape reaches nothing.

▶18:42 / 26:101×2×4×8×Skip idle

Alex

Every keystroke is timed and attributed. The diamonds are runs, and idle time collapses on playback – a 40-second think-pause replays in a blink.

The second reader

Nothing relies on the interviewer's memory

Minutes after the session ends, the recording and a synced transcript are ready. Our AI reviews the entire session – the transcript, the coding playback, the interviewer's notes and checked criteria, and the question's scoring guide. It helps organize that material, suggests draft wording and flags evidence the interviewer may have missed. The experienced interviewer makes every judgment, edits the report and signs it.

✓Transcript lines are links: click one and the recording seeks to that moment. Search it instead of scrubbing it.

✓Suggestions are diffs against the interviewer's rubric, not a ghost-written report.

✓Disagreement is the point – it's a QC pass built to catch misses, not to agree.

AI assistancereads transcript · rubric · notes · coding playback

Transcript, synced to the recording

31:02Alex: Memo alone does not solve it because the list still has ten thousand live nodes.

31:18Sarah: What would you measure to prove it?

31:42Alex: We cut p95 frame time from 87 milliseconds to about 4.

32:05Sarah: And where does this approach break at a million rows?

Every line is a link. Click it and the recording seeks to that moment.

AI suggestions (2)Accept allReject all

+ Check: Measured performance improvement quantitatively✓✕

Evidence at 31:42, said aloud but missing from the notes.

AI suggested notes

Quantified the improvement without prompting (p95 87 ms → 4 ms, 31:42) and reasoned about the failure mode at higher cardinality (32:05). Consider reflecting both in the write-up.

AcceptReject

Suggestions are diffs against the interviewer's rubric. They accept, correct, and sign – nothing publishes itself.

Run it yourself

Your team can run interviews here too

Everything above also works self-service: your engineers conduct, and the platform brings the structure – the teleprompter, the recording and the playback, ready-made. AI helps organize notes and suggest draft wording, while your interviewer makes the decisions and signs the report. Many teams mix the two: we run the early rounds, they run the onsites, and every candidate ends up in one comparable record.

See the full pricing ↗

Run one interview.Read the report.

You've just seen everything that goes into one. The fastest way to judge it is to send a real candidate through and put the report in front of your team.

Run your first interview Or read how PayPlan ran 60 of them ↗