Every round of a real loop, run the way it is run.
A screen, a coding round, two design rounds and a behavioral conversation. Each has its own room and an interviewer that knows what that round is for. Pick the one you are preparing for.
- 0115-45 minTechnical ScreenVoice conversation, no editorSee the round
- 0230-60 minData Structures & AlgorithmsCode editor, sample and custom tests, consoleSee the round
- 0345-60 minSystem DesignArchitecture canvas, capacity calculator, API and table notesSee the round
- 0430-60 minLow-Level DesignClass-design canvas, multi-file editor, test runnerSee the round
- 0520-45 minBehavioralVoice conversation, private notesSee the round
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.
- Introduction
- Background
- Resume deep-dive
- Fundamentals
- Role fit
- 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
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
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.
- Problem
- Clarify
- Approach
- Complexity
- Code
- Test
- 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
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)
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();
}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.
- Clarify
- Capacity
- Architecture
- Deep dive
- 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
Your numbers carry forward: the deep dive holds you to them.
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.
- Clarify
- Approach
- Design
- Implement
- Test
- 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
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.
- Warm-up
- Competency blocks
- Your questions
- 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
Payment worker memory leak
gRPC or REST between services
Told once · result missing
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.
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.
What the candidate says
The transcript is the interviewer's memory of the conversation: what was claimed, what was asked, what was answered.
What the candidate writes
The interviewer sees the code as it changes, where the cursor is, and whether the last run passed or failed.
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.
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.
const acquired = await this.redis.setNx(lockKey, "locked", 30);
if (!acquired) throw new DuplicatePaymentError();A lock is taken with a 30-second TTL, and nothing in the file releases it.
The question
“You've acquired the lock with a 30-second TTL. What happens if the payment gateway takes 35 seconds to answer?”
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.
Build better interviews.
Practice with structure. Hire with evidence.