At a glance

The five rounds, side by side

What each one takes, what you work in, and what your browser needs before you start.

  • 01Technical Screen
    Length
    15 / 20 / 30 / 45 min
    You work in
    Voice conversation, no editor
    Languages
    None - spoken
    Devices
    Camera, microphone and full screen; screen sharing optional
    Hints
    None - it is a conversation
  • 02Data Structures & Algorithms
    Length
    30 / 45 / 60 min
    You work in
    Code editor, sample and custom tests, console
    Languages
    Java, Python, JavaScript, C++17
    Devices
    Camera, microphone, screen sharing and full screen
    Hints
    Four levels, one at a time, and noted in the report
  • 03System Design
    Length
    45 / 60 min
    You work in
    Architecture canvas, capacity calculator, API and table notes
    Languages
    None - spoken
    Devices
    Camera, microphone and full screen
    Hints
    A nudge when you are stuck
  • 04Low-Level Design
    Length
    30 / 45 / 60 min
    You work in
    Class-design canvas, multi-file editor, test runner
    Languages
    Java, Python
    Devices
    Microphone
    Hints
    Three levels, and noted in the report
  • 05Behavioral
    Length
    20 / 30 / 45 min
    You work in
    Voice conversation, private notes
    Languages
    None - spoken
    Devices
    Microphone; camera optional
    Hints
    Coach mode adds feedback after each story

Every round is recorded only with your consent, and every report quotes the transcript and code it was built from.

01 / 05 · 15-45 min

Technical Screen

A recruiter-style first conversation on your background, your resume's claims and the fundamentals of the role you are targeting.

  1. Introduction
  2. Background
  3. Resume deep-dive
  4. Fundamentals
  5. Role fit
  6. Wrap-up
Length
15, 20, 30, 45 min
You work in
Voice conversation, no editor
Devices
Camera, microphone and full screen; screen sharing optional
Hints
None - it is a conversation
From your resumeBackend engineer

Claim worth checking · Kafka

“Scaled the consumer pipeline to 120k msgs/sec with zero message loss.”

Claim worth checking · PostgreSQL

“Removed table locks from migrations with composite indexes.”

Sections planned for 30 minutes

Background · Resume deep-dive · Databases · Distributed systems · Role fit

ConversationResume deep-dive

Interviewer

“Your resume says 120k messages a second. When a consumer dies halfway through a batch, how did you keep processing idempotent?”

You

“We committed offsets in the same transaction as the write, through an outbox table, so a rebalance could not process a message twice...”

Follow-up it earned

“What did the outbox cost you in write throughput, and how did you measure it?”

What the interviewer is after

  • Numbers and claims on your resume, asked about the way a screener would
  • Fundamentals for the role: databases, operating systems, networking, OOP
  • A different framework treated as transferable, not as a gap
  • "I don't know" handled without penalty, then a simpler question

What your report shows

  • Readiness for the next round - never a hiring decision
  • Competency ratings with confidence
  • Role fit and the requirements you met
  • Gaps ranked, each tied to a moment you can replay

02 / 05 · 30-60 min

Data Structures & Algorithms

A LeetCode-style problem worked out loud: clarify, pick an approach, argue its complexity, then code and test it in a real judge.

  1. Problem
  2. Clarify
  3. Approach
  4. Complexity
  5. Code
  6. Test
  7. Follow-up
Length
30, 45, 60 min
You work in
Code editor, sample and custom tests, console
Languages
Java, Python, JavaScript, C++17
Devices
Camera, microphone, screen sharing and full screen
Hints
Four levels, one at a time, and noted in the report
ProblemMedium · Heap

Meeting Rooms II

Given meeting intervals [[s1,e1],[s2,e2],...], return the minimum number of rooms needed so that no two meetings in the same room overlap.

Language

What you are asked to argue

Time O(n log n) · Space O(n)

Solution.java Run · Submit
public int minMeetingRooms(int[][] intervals) {
  Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
  PriorityQueue<Integer> ends = new PriorityQueue<>();
  for (int[] m : intervals) {
    if (!ends.isEmpty() && m[0] >= ends.peek()) ends.poll();
    ends.add(m[1]);
  }
  return ends.size();
}
SAMPLE TESTS2 / 2 passed
[[0,30],[5,10],[15,20]] → expected 2, got 2
[[7,10],[2,4]] → expected 1, got 1

What the interviewer is after

  • Whether you clarified inputs and edge cases before coding
  • The approach you chose, and why not the obvious alternative
  • Time and space complexity, checked against the code you wrote
  • How you test and debug when a hidden case fails

What your report shows

  • Evidence per dimension: approach, correctness, complexity, communication
  • Every run and submission, with the code that produced it
  • Hints used and when
  • Next topics to practise

03 / 05 · 45-60 min

System Design

Design a system at scale on a real canvas: set the scope, size it with napkin math, draw it, then defend it in a deep dive.

  1. Clarify
  2. Capacity
  3. Architecture
  4. Deep dive
  5. Final review
Length
45, 60 min
You work in
Architecture canvas, capacity calculator, API and table notes
Devices
Camera, microphone and full screen
Hints
A nudge when you are stuck
Step 3 of 5 · Architecture 41:07 remaining
Clarify
Capacity
Architecture
Deep dive
Review
Back-of-the-envelopecalculator
Daily active users100 M
Read : write ratio100 : 1
Peak read QPS1.2 M
Storage / 5 yrs36 TB

Your numbers carry forward: the deep dive holds you to them.

Component canvas6 nodes · 5 edges
CDN
edge
Load balancer
edge
API service
compute
Redis cache
cache
Kafka
queue
Sharded SQL
storage

Interviewer

“At 1.2 M reads a second the cache is doing the real work. What happens the moment a hot key expires?”

Probed: cache stampede, single points of failure, hot shards

Trade-offs you name are quoted in the report, next to the moment you said them.

What the interviewer is after

  • Functional scope and the non-functional targets you commit to
  • Capacity numbers, recomputed so the deep dive holds you to them
  • Caches, queues, sharding and replication, and what each costs
  • Failure modes: hot keys, stampedes, single points of failure

What your report shows

  • Scored only from your diagram and what you said
  • Capacity estimates checked server-side
  • Trade-offs you named, quoted next to the moment
  • Nothing scored when nothing was produced

04 / 05 · 30-60 min

Low-Level Design

A machine-coding round: clarify the requirements, sketch the classes, implement across several files and defend the design under follow-ups.

  1. Clarify
  2. Approach
  3. Design
  4. Implement
  5. Test
  6. Follow-up
Length
30, 45, 60 min
You work in
Class-design canvas, multi-file editor, test runner
Languages
Java, Python
Devices
Microphone
Hints
Three levels, and noted in the report
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?”

What the interviewer is after

  • The requirements you asked about - and the ones you assumed
  • Class boundaries, interfaces and where the patterns really help
  • Code that runs: your tests, plus hidden ones where the question has them
  • Follow-ups that point at the class and the line you just wrote

What your report shows

  • Fifteen categories grouped into clear dimensions
  • Correctness from your last test run
  • The reference design, released after the session
  • Practice topics for next time

05 / 05 · 20-45 min

Behavioral

Tell real stories from your work. The interviewer follows up like a trained one - on what you did, what changed, and what you learned.

  1. Warm-up
  2. Competency blocks
  3. Your questions
  4. Wrap-up
Length
20, 30, 45 min
You work in
Voice conversation, private notes
Devices
Microphone; camera optional
Hints
Coach mode adds feedback after each story
Your story bank2 stories

Payment worker memory leak

S · clearT · clearA · clearR · thin

gRPC or REST between services

Told once · result missing

Follow-up on the gapOwnership

Interviewer

“Tell me about a technical decision you made that didn't go to plan.”

You · Action

“I put an in-memory cache in front of the query to fix p99 latency, but we hadn't planned for cold starts...”

The result was thin, so it asks

“What changed afterwards - what did you measure, and what would you do differently?”

What the interviewer is after

  • Situation, task, action, result - and which parts are missing
  • "I" versus "we": whose work the story describes
  • Whether a result has a number or an observable outcome
  • Follow-ups on the gap, capped by the style you chose

What your report shows

  • Competency cards with verbatim quotes and the bar for your level
  • A STAR breakdown of every story
  • A tightened rewrite that only uses facts you stated
  • Stories saved to your story bank for next time

For hiring teams

Put any of the five into one assessment

Choose the rounds and their order, fix the rubric before the first invitation, and review a dossier where every score cites the code, transcript or test run behind it.

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
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