AI technical interviews, with the evidence attached

Interviews that show their work.

An AI interviewer that questions the code as it is written, across design, systems, algorithms and behavioural rounds - and a dossier where every score cites what was said and done.

Real questions. Recorded evidence. Better decisions.

  • Questions about the candidate's own code
  • Integrity timeline in every dossier
  • Greenhouse, Lever and Ashby webhooks
Meritello Live StudioLIVE SESSION
23:45 / 45:00

Meritello AI

Low-Level Design · Concurrency

Live transcript

Interviewer Question (Turn 1 of 3)

“Walk me through your approach to handling concurrent payment requests in PaymentService.”

Candidate Audio Stream (Speech-to-Text)

“I'm using Redis with a TTL as a fast-fail gatekeeper before the primary database transaction. Then in the finally block, we guarantee lock cleanup even if the network call fails...”

Test Suite · PaymentService.spec.ts3 passed · 0 failing
  • idempotentLockAcquiredOnFirstCall12ms
  • rejectsDuplicateWithPayload8ms
  • lockGuaranteedReleasedOnThrow19ms
Line 6 active
1class PaymentService {
2 private readonly idempotencyStore: RedisClient;
3 private readonly gateway: PaymentGateway;
4
5 async processPayment(req: PaymentRequest): Promise<PaymentResult> {
6 const lockKey = `pay_lock:${req.idempotencyKey}`;
7 const acquired = await this.idempotencyStore.setNx(lockKey, "locked", 30);
8 if (!acquired) {
9 throw new DuplicatePaymentError(req.idempotencyKey);
10 }
11 return await this.gateway.charge(req);
12 }
13}
Real-time Evidence Detected
High signal

“Candidate proactively stated idempotency requirement and identified race conditions.”

Rubric: Requirements & ArchitectureMapped to Final Report
Transcribed · code synced · tests runningObservable Session #4928
5

Kinds of round

Low-level design, system design, DSA, technical screen and behavioural - each on its own engine, all in one assessment.

1:1

Scores to evidence

Every criterion score cites code lines, a transcript moment or a test run. A citation that points at nothing is dropped, not stored.

0

Assumed signals

Integrity comes only from what the room recorded. A signal that was not captured is shown as not captured, never as a clean score.

3

ATS webhooks, both ways

Greenhouse, Lever and Ashby: a stage change invites the candidate; a submission and a decision post the scorecard back, signed.

What the product holds itself to
  • Recording only with consent
  • Deleted when the candidate asks
  • No emotion or personality inference
  • Rubric fixed before the interview

Against the usual ways

What an interview with the evidence attached changes.

An online judge, a take-home and a panel each answer one question well. Here is what each leaves out, and what Meritello does instead.

CapabilityMeritello
The candidate is questioned about their own code

Follow-ups come from what was written and said in the room, not from a script.

An AI interviewer asks about the code as it changes, and every question must cite something the candidate said or wrote

Checked before it is spoken
How you know the work is theirs

Signals recorded during the round, shown to the reviewer on a timeline.

Focus, full screen, pasting (refusable), camera and connection are recorded with timestamps; nothing uncaptured is scored

Recorded, never assumed
Kinds of round in one loop

What a senior hire actually needs to demonstrate.

Low-level design with running tests, system design on a whiteboard, DSA, technical screen and behavioural

5 kinds
What the reviewer sees behind a score

A number is only as good as what it points at.

Each criterion score cites code lines, transcript moments or test runs; overrides need a written reason

Cited or dropped
How it reaches the ATS

Where the hiring team already works.

A stage change in Greenhouse, Lever or Ashby invites the candidate; the scorecard is posted back, signed; rules can move an application on their own

Both directions
What the candidate gets afterwards

Whether the person who did the work learns anything from it.

The full report with cited evidence and practice drills - or only a confirmation, if the hiring team keeps results private. Their choice, per assessment

The team decides
The Meritello column describes the product as built. The others describe approaches, not any vendor’s figures.See the employer workspace

The interviewer

An interviewer that listens, and reads the code.

It does not follow a script. Each question comes from what was just said and what was just written, and it has to point at one of those to be spoken at all.

Transcribed as they speak

What the candidate says

The transcript is the interviewer's memory of the conversation: what was claimed, what was asked, what was answered.

Files, the diff, the last run

What the candidate writes

The interviewer sees the code as it changes, where the cursor is, and whether the last run passed or failed.

Fixed before the interview

What the rubric asks for

The criteria and their anchors are written by the hiring team ahead of time; the interviewer works towards them and never reveals them.

Checked before it is spoken

What it decides to say

One question at a time, in the hiring team's chosen manner. A question that cites nothing the candidate said or wrote is rejected and replaced.

Three moments, and the question each one earned
ConcurrencyCode synced
const acquired = await this.redis.setNx(lockKey, "locked", 30);
if (!acquired) throw new DuplicatePaymentError();
What the interviewer noticed

A lock is taken with a 30-second TTL, and nothing in the file releases it.

Interviewer
spoken, then shown

The question

“You've acquired the lock with a 30-second TTL. What happens if the payment gateway takes 35 seconds to answer?”

Criterion it servesFixed before the interview

Concurrency and fault tolerance

It asks; it does not answer. Hints, when the hiring team allows them, come one level at a time and only when asked or when the candidate is stuck.

No script, no verdict mid-interviewEvery line goes into the record

Integrity

What the room recorded, on a timeline, with the arithmetic shown.

The rooms record focus, full screen, pasting, the camera and the connection - with timestamps and durations. A reviewer scrubs to any moment. The score is a sum, not a verdict, and the hiring team chooses how strict the round is.

Webcam and audio recorded, paste events audited, flagged after 3 tab switches.

Integrity · sample roundStandard
Low-level design · 45 min Integrity 86/100
23:40 / 45:00Click a marker to read the signal
low23:40
−2 points

Copy paste

Pasted 780 characters

As storedone row, never edited

{ type: "COPY_PASTE", severity: "low", atMs: 1420000, metadata: { chars: 780 } }

This profile records
  • Camera on, audio recorded
  • Pasting allowed and recorded
  • Flagged past 3 times leaving the room
Start100
1 medium signal × 6−6
4 low signals × 2−8
Integrity86

A sum, not a verdict. The reviewer sees every signal with its timestamp and decides. Nothing here accuses anyone.

Two sides of the table

One platform. Two sides of the interview table.

A hiring team and a candidate see the same record of what happened in the room. The team decides how much of it the candidate keeps.

Employer workspaceGreenhouse, Lever and Ashby webhooks

Defensible hiring decisions backed by facts, not hunches.

Assessments built from up to five kinds of round, rubrics with written anchors, and a dossier for every candidate where each score cites the moment it came from.

See the employer workspace

Kinds of round

5

Any of them in one assessment

Blind review

On/off

Names masked while the evidence is read

Score overrides

With a reason

Kept beside the machine’s score

Team notes

Cited

Each one can point at a line or a moment

Sample loop · Senior Backend EngineerNumbers illustrative
01 · Tech Screen30m

Resume verification & CS fundamentals

42 Passed · 94% score
02 · System Design45m

Distributed capacity & architecture

18 Advanced · Calibrated
03 · Low-Level Design60m

OOP machine coding & live tests

8 Reviewing · Full Dossier
04 · STAR Leadership30m

Technical trade-offs & crisis ownership

4 Final Offers

Five Interview Rounds

One platform. Five ways to evaluate engineering ability.

Each round runs in its own room - an editor, a canvas or just a conversation - with an interviewer that knows what that round is for.

04 · Low-Level DesignMachine coding

Clarify → Design → Code → Test → Defend

Object-oriented modelling, extensibility and working code, across several files, with tests.

Start Low-Level Design
Step 3 of 5 · Implementation 28:14 remaining
Clarify
Design
Code
Test
Defend
Class-design canvas3 classes
interface SpotAssignmentStrategy
+ assignSpot(vehicle: Vehicle, lot: ParkingLot): Spot
▼ implements
NearestEntrancePolicy
PriorityQueue<Spot>
EvenDistributionPolicy
Round-robin by level
ParkingLotService.java3 / 3 tests passing
public class ParkingLotService {
  // Strategy injected so spot choice can change without touching parking
  private final SpotAssignmentStrategy assignment;

  public Ticket park(Vehicle v) {
    Spot spot = assignment.assignSpot(v, this);
    return Ticket.open(v, spot, clock.instant());
  }
}

Interviewer

“You separated the assignment strategy. What happens when two cars reach different gates in the same millisecond and both are offered the last spot?”

Interactive preview

See how the interviewer adapts.

Pick an answer and watch the follow-up change. The real interviewer generates every question from what you say and write - this is a scripted preview of that behaviour.

Scripted preview - not the live interviewerSpeaking
Interviewer:
ParkingLotService.javaLevel.java
  1. public class ParkingLotService {
  2. private final List<Level> levels;
  3. private final SpotAssignmentStrategy strategy;
  4. public Ticket park(Vehicle vehicle) {
  5. for (Level level : levels) {
  6. Spot spot = level.findFreeSpot(vehicle.size());
  7. if (spot != null) return issueTicket(spot, vehicle);
  8. }
  9. throw new LotFullException(vehicle);
  10. }
  11. }

Feedback for this exchange

Appears after the follow-up: two things that went well and one thing to work on, tied to the answer you gave.

Real Developer Environment

A coding workspace built for real interviews.

Interviews shouldn't feel like typing into a dumb text area. Meritello provides a full-featured Monaco environment equipped with the tools senior engineers actually rely on.

Meritello Studio · workspace
RateLimiter.javaTokenBucket.javaRateLimiterTest.java
UTF-8Java 17 LTS
Suggestions · TokenBucket
  • tryConsume(int tokens)boolean
  • refillTokens()void
  • getAvailableTokens()int
1package com.meritello.ratelimiter;
2
3public class RateLimiter {
4 private final int capacity;
5 private final AtomicInteger currentTokens;
6
7 public boolean acquire(int permits) {
8 while (true) {
9 int current = currentTokens.get();
10 if (current < permits) return false;
11 if (currentTokens.compareAndSet(current, current - permits)) {
12 return true;
13 }
14 }
15 }
16}
0 errors 1 warning (unused variable in RateLimiterTest)
Spaces: 4Matching Brackets: onPrettier: formattedShortcuts: ⌘/ comment · ⌘D multi-select · ⌥↑ move line

The dossier

Every score names what it saw.

A citation is a link: to lines of code, to a moment in the recording, to a test run. A reviewer clicks it and looks. A score without one is not stored.

01. InterviewCode, speech and test runs, as they happen
02. EvidenceKept with timestamps: recording, code history, runs
03. EvaluationThe rubric applied, each score with a citation
04. ReviewA reviewer checks the citation, overrides with a reason
05. DecisionRecorded, and posted to the ATS

Dossier · one criterion, opened

Low-level design round · Parking lot · Java

Rubric chosen before the invitation

Object design

5 / 5 · weight 30%
#code:ParkingLotService.java:14-22

“Spot selection sits behind a strategy. When asked about EV bays at 01:14:32, said a new bay type is a new class, and the tests agree.”

ParkingLotService.java · lines 14 to 22version at 01:14:32
// 14 private final SpotAssignmentStrategy assignmentStrategy;
// 15
// 16 public Optional<Ticket> parkVehicle(Vehicle vehicle) {
// 17   ParkingSpot spot = assignmentStrategy.findOptimalSpot(vehicle, availableSpots);
// 18   if (spot == null) return Optional.empty();
// 19   spot.occupy(vehicle);
// 20   return Optional.of(new Ticket(UUID.randomUUID(), vehicle, spot, Instant.now()));
// 21 }
// 22

Why these lines

The anchor for a 5 reads “extends by adding a class, not a branch; says so before being asked.” The strategy field is the class; the transcript at 01:14:32 is the saying so.

Every version of the file is keptscrub to any moment

One record. Who sees what is the hiring team’s call.

Reviewers see the dossier with names masked while reading, and the scorecard posts to the ATS on a decision.

Pipeline

What happens on its own, and how the ATS hears about it.

A stage change in Greenhouse, Lever or Ashby invites the candidate. When they submit, rules the team wrote can move the application, and the scorecard is posted back - signed, with the rounds and the dossier link.

Rules run when an application is submittedEach fires once per application · every firing leaves a note
The note it leaves in the dossier

“Moved to final review automatically: score 4.40 is at least 4.20.”

Signed by nobody: the platform wrote it. A reviewer’s override that moves the score runs the rules again; one that already fired does not fire twice.

The hiring workspace

One pipeline, every round in it, every score with its evidence.

Openings, assessments, applications and dossiers in one place. Click a stage to filter; click a candidate to open the evidence.

M

Meritello

Acme Engineering · sample data

Blind review is on

Names are masked while a reviewer reads a dossier. Overrides need a written reason.

Active Assessments

12

2 activated this month

Candidates

148

every score cites evidence

Interviews This Week

34

22 completed · 12 scheduled

Completion Rate

92%

of invitations submitted within 14 days
Pipeline(Click stage to filter)
98 total in flight
Recent submissions
Click a candidate to open the evidence
Alex Chen4.8 / 5.0ParkingLotService.java:34
Posted to Greenhouse

“Put spot selection behind a strategy, so a new bay type is a new class, not a new branch.”

The assessment studio

Compose the loop once. Every candidate takes the same one.

Up to five kinds of round, each with its own problem and length; one proctoring profile; one rubric. Activate it and invitations can go out - by email, by a public link, or from a stage change in your ATS.

DraftSenior

Backend Engineer

165 min across 4 rounds
Proctoring, for every round
Webcam and audio recorded, paste events audited, flagged after 3 tab switches.
  1. Round 1screen

    Technical screen

    Resume-aware · fundamentals and the job description

  2. Round 2dsa

    Data structures & algorithms

    One problem · Java or Python · tests run in the room

  3. Round 3lld

    Low-level design

    Parking lot · Java · running tests

  4. Round 4behavioral

    Behavioral

    Ownership, problem solving, collaboration

The rubric studio

Define what good looks like before the interview starts.

Weighted criteria, five anchored levels each, written by the hiring team and chosen before the first invitation. Every candidate in the opening is scored against the same one.

Criteria first.→Evidence second.→Decision last.
Competency Weighting

L5 · Senior Engineer

Total: 100%
Architecture & Low-Level Design (SOLID)25%
Thread Safety & Concurrency Primitives25%
Algorithmic Optimizations & Invariants20%
Defending Architectural Trade-offs20%
Production Resiliency & Failure Modes10%

What the rubric holds still

The rubric is chosen when the assessment is activated and applies to every candidate invited to it. A reviewer who disagrees with a score overrides it in the dossier with a written reason, which stays on the record next to the original.

Five anchored levels

Focus on resilient architecture, optimistic concurrency, and system modularity

Scored 1 to 5, each with a citation

Transparency For Candidates

Candidates see the evidence too.

No vague rejection emails or black-box silence. You receive a structured dossier showing what you demonstrated, where you excelled, and exact moments to practice for next time.

Post-Interview Synthesis Report

Software Engineering Loop · Completed

Technical Screen DSA LLD Behavioral

What you demonstrated

  • Strong problem decomposition: Broke down parking spot allocation into decoupled size-based indexes.
  • Clear communication: Articulated database vs cache trade-offs aloud before writing code.
  • Good complexity analysis: Accurately derived O(1) spot lookup vs O(N) naive search.

Areas to improve

  • Testing edge cases: Unhandled concurrent spot allocation when level is 99% capacity.
  • System design tradeoffs: Initially coupled pricing calculation directly inside the Vehicle entity.
Evidence Citing Your SessionTimestamp: 00:24:12
Quoted Transcript

“Candidate noted: ‘I will assume only one car parks at a time for now.’ Interviewer followed up on thread safety.”

Code Reference

Line 14 in ParkingLotService.java lacked synchronization lock.

Recommended Next Practice Drill

Practice: “Thread-Safe In-Memory Key-Value Store with TTL” (Targeting Concurrency)

Start Practice Drill

The Continuous Loop

One interview can become the next step in your preparation.

Interviews shouldn't be isolated dead ends. In Meritello, every session generates structured learning signals that feed back into targeted practice, turning past friction into future mastery.

Step 1

Practice

Work on algorithmic invariants, OOP patterns, and system design canvases.

Cycle stage
Step 2

Interview

Take a realistic, voice-driven mock session with adaptive follow-ups.

Cycle stage
Step 3

Evidence

Every utterance, keystroke, and test result is logged into an objective record.

Cycle stage
Step 4

Feedback

Receive clear, timestamped observations tied to pre-published rubrics.

Cycle stage
Step 5

Improvement

Turn identified gaps into tailored practice drills in your candidate dashboard.

Cycle stage
Step 6

Practice Again

Return to the arena with measurable progress and renewed confidence.

Cycle stage

Commitments & Principles

Trust built on radical transparency.

Automated technical hiring earned its bad reputation by scoring engineers on hidden signals and refusing to explain itself. Meritello is built on six non-negotiable commitments.

  • Evidence, never a verdict.

    Every rating cites the moment it came from. Scores are backed by lines of code, test outcomes, and quoted speech—never by an unexplainable verdict.

    Principle 1 of 6
  • The candidate sees what the company sees.

    Complete symmetry of information. There is no secret back-channel evaluation or separate shadow scorecard kept out of the interviewee's hands.

    Principle 2 of 6
  • The interviewer always identifies itself as AI.

    Disclosed clearly at the start of every session. Meritello never mimics a human interviewer deceptively or masks its machine nature.

    Principle 3 of 6
  • Session signals describe what happened; they do not accuse.

    Window blurs or audio disconnections are recorded as neutral, timestamped operational facts. They never become accusations of cheating on their own.

    Principle 4 of 6
  • Recordings belong to the person in them and can be deleted on request.

    Stored privately in encrypted storage. You retain absolute ownership and can permanently purge your recordings, code, and dossiers at any time.

    Principle 5 of 6
  • Criteria are published before evaluation.

    Rubric anchors, competence weightings, and stage requirements are transparently published before the timer starts, so no one walks in blind.

    Principle 6 of 6

Privacy & trust

Built for people who are recording themselves.

Practising an interview means speaking, sharing a screen and being recorded. These are the rules the product holds itself to.

  • Recording starts when you press Start, never before

    The system check releases the camera and microphone as soon as it finishes. Consent is per device and the camera is optional in voice rounds.

  • Recordings stay private

    Video and audio go to private object storage. Playback happens through short-lived signed links issued only to you; nothing is public and nothing is embeddable.

  • Delete any session, including the recording

    One action removes the transcript, code, report and recorded media for that session. Deleting a behavioral session also removes the stories it created.

  • Session signals are evidence, never a verdict

    Leaving fullscreen or losing focus is recorded as a signal with its timestamp, shown to you in your own report. It never becomes an accusation or a score on its own.

  • No emotion, personality or appearance inference

    Ratings quote what you said and wrote. Nothing is inferred from your face, your voice or your accent, and reports never contain a hiring verdict.

  • Access is controlled and audited

    Email verification to start a session, two-factor authentication for every staff account, and an append-only audit log of every administrative action.

The full detail is in the privacy policy and the terms of service. Ask a question

FAQ

Questions people ask before their first session.

Is the interviewer a real person?
No. The interviewer is AI-powered. It is designed to sound and behave like an experienced engineer - it greets you, listens, asks follow-ups and reads your code - but it always says so, and it never pretends to be human.
How are questions generated?
Each question is produced during the session from the problem, what you have said so far, the code and diagram in your workspace, your latest compile and test results, the current stage and the time left. There is no fixed script, so two candidates on the same problem get different follow-ups.
Which languages are supported?
Java and Python today, each with a multi-file starter project, a test harness and sandboxed execution. Other languages are not yet available.
Does the interviewer understand all my files?
Yes. Every file in the workspace is read as you write it - classes, methods and individual lines - along with compiler diagnostics, test results and what changed since the last time it looked.
Are interviews recorded?
Your voice is transcribed to text in real time; the audio itself is not stored. The transcript text, your code snapshots, diagram and notes are saved to your account so the feedback report can quote them.
How is my code protected?
Code runs in an isolated sandbox with time and resource limits and is tied to your account only. You can delete any session, including its code and transcript, from your history.
Can I repeat an interview?
Yes. Repeat the same problem or pick a different one whenever you like. Your history keeps every report so you can compare attempts.
Do I receive feedback?
After every session you get a scored report per dimension with evidence from your own transcript and code, strengths, improvement areas and a recommended next topic. You also get an email when the report is ready.
Is there a free interview?
Yes. You can create an account and start an interview for free, with no credit card.
What equipment do I need?
A laptop or desktop with a microphone and a current version of Chrome, Edge or Safari. Headphones are recommended so the interviewer's voice is not picked up by your microphone.
Get Started Today

Build better interviews.

Practice with structure. Hire with evidence.

Free candidate practice No credit card required Recorded with consent, deleted on request