Meritello for Candidates & Students

Walk into interviews prepared.
Never surprised.

Practice high-stakes technical interviews with an adaptive AI interviewer that listens, reads what you code, probes your architectural decisions, and returns feedback quoting your exact words.

Real problems, not trivia
AI interviewer that reads your code in real time
Feedback citing your exact audio timestamps and code lines
Practice sessions are yours; no employer sees them
A practice round, one moment of it

Interviewer

System design · 45 min

speaking

Asked about what you just did

“You've put a rate limiter in front of the API. Twenty pods share it - where does the count live, and what happens when two pods check it at the same instant?”

Hints0 of 2 used

System design rounds nudge rather than hint: one narrower question, when you are stuck.

What the report will saycites this moment

Named the race between check and increment unprompted; moved to an atomic script when asked what happens under contention.

Criterion: Concurrency and consistency

Rate limiter · whiteboard + capacitywhat the interviewer has in front of it
Components: API gateway → rate limiter → services
Store: Redis, one key per client ("rl:{clientId}")
Algorithm: sliding window, ZADD timestamp / ZREMRANGEBYSCORE
Capacity: 100k req/s · 20 pods · ~5k checks/s per pod
A practice session is yours: no employer sees itdelete it from the report page
5

Kinds of round to practise

Low-level design with running tests, system design on a whiteboard, DSA, a technical screen and a behavioural round - the same engines hiring teams use.

1 at a time

Hints, when you ask

A ladder of hints, each a little more specific, given only when you ask or when you are stuck. Noted in your report, never held against you in practice.

Cited

Every line of feedback

The report quotes the code lines and transcript moments it is about, so you can see exactly what earned each remark.

Yours

Practice stays private

A practice session belongs to you. No employer sees it, there is no public profile, and you can delete any session from its report page.

What the product holds itself to
  • Recording only with your consent
  • Delete a session whenever you like
  • No emotion or personality inference
  • Your stories, kept for the next round

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

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

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.

Code-aware interviewer

It reads your code the way a senior engineer would.

Every file in your editor is part of the conversation. Questions point at the class, the method and the line - and they change when the code does.

ParkingLotService.javaVehicle.javaLevel.java
  1. package lot;
  2. public class ParkingLotService {
  3. private final Map<Size, Deque<Spot>> free = new EnumMap<>(Size.class);
  4. public Ticket park(Vehicle v) {
  5. Spot spot = free.get(v.size()).pollFirst();
  6. if (spot == null) throw new LotFullException(v);
  7. return new Ticket(spot, v, clock.instant());
  8. }
  9. static class Bus extends Vehicle {
  10. Bus() { super(Size.LARGE, 5); }
  11. }
  12. }
Interviewer: In ParkingLotService.java, why did you choose inheritance here instead of composition?

What it is reacting to

  • The interviewer understands
  • Files
  • Classes
  • Functions
  • Line-level implementations
  • Compilation errors
  • Test results
  • Changes made during the discussion

Dynamic conversation

Questions aren't hardcoded. They branch on what you decide.

The same problem leads somewhere different depending on the design you choose, the code you write and how the interview is going.

Problem

Design a parking lot

Multiple levels, three vehicle sizes, tickets at entry and exit.

Your design decision
Where the interview is

The interviewer asks

  1. What does the strategy interface take and return?
  2. Who owns the free-spot state - the strategy or the level?
  3. How does 'nearest to entrance' fit the same interface?

What the interviewer takes into account

  • Previous answers
  • Design decisions
  • Code changes
  • Test results
  • Interview stage
  • Remaining time

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

Story bank

Every story you tell is kept, with what it was missing.

A behavioural round is a handful of stories told well. After each one, the bank records which STAR parts were there, whose actions they were, and the numbers you gave - and offers to drill the story again until it holds up.

The 2 a.m. settlement deadlocktold 1 time · best telling 74% complete

A flash sale, two services taking the same locks in opposite orders, and eleven minutes to get checkout back.

  • Ownership
  • Problem solving & judgment
  • Failure & resilience
The five partsas the bank marked them
Action thin

Told as "we" throughout. The rate limit at the gateway was the key call - whose was it?

Whose actions
Mostly "we"
Numbers you gave
18 s → 38 ms11 min0 duplicate charges
The follow-up this story earned
Because: Whose actions were these

“What did you personally decide in the first ten minutes, and what did you leave to the team?”

A telling that would mark it clear

“I made the call to shed non-critical reads at the gateway before we touched the database - that bought the time to trace the lock cycle.”

What to add next time
  • –Say which decision was yours, even if the team executed it.
  • –Add one sentence on what you changed in how you work.

One click drills a single story: the interviewer asks for it again and follows up on exactly what was thin.

Practise a behavioural round

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

Candidate Plans

Free during beta. Fair forever.

We believe nobody should be filtered out because they could not afford realistic interview practice.

Community Practice
$0/ forever during beta

Every kind of round, with the same interviewer hiring teams use.

  • All five kinds of round
  • A voice interviewer that reads your code
  • Editor with running tests
  • Report with scores and a summary
Start Practicing Free
Most Popular
Pro Candidate
$24/ month

The full report, and drills aimed at what it found.

  • Everything in Community Practice
  • Every remark cites a code line or a moment
  • Drills aimed at what the report found
  • Story bank with single-story drills
View Candidate Plans

Frequently Asked Questions

Questions from candidates

Is Meritello really free to practice during beta?

Yes. Candidates can practise low-level design, system design, DSA, technical screen and behavioural rounds for free during the public beta.

Will any employer or recruiter see my mock interview results?

Not a practice session - that belongs to you, and you can delete it from its report page. If a company invites you to take one of its assessments, that round is theirs to review, and the invitation page says so before you start.

How does the AI interviewer follow up on my code?

It sees the files as you edit them, where your cursor is, and the result of every run. Each question has to point at something you wrote or said, or it is not asked.

Can I repeat questions or focus solely on concurrency or algorithms?

Yes. Pick the kind of round, the topic and the difficulty; ask the interviewer to repeat a question at any time; and drill a single behavioural story from the story bank.

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