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.
Interviewer
System design · 45 min
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?”
System design rounds nudge rather than hint: one narrower question, when you are stuck.
Named the race between check and increment unprompted; moved to an atomic script when asked what happens under contention.
Criterion: Concurrency and consistency
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 podKinds 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.
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.
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.
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.
- 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.
Clarify → Design → Code → Test → Defend
Object-oriented modelling, extensibility and working code, across several files, with tests.
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.
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.
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.
- public class ParkingLotService {
- private final List<Level> levels;
- private final SpotAssignmentStrategy strategy;
- public Ticket park(Vehicle vehicle) {
- for (Level level : levels) {
- Spot spot = level.findFreeSpot(vehicle.size());
- if (spot != null) return issueTicket(spot, vehicle);
- }
- throw new LotFullException(vehicle);
- }
- }
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.
- package lot;
- public class ParkingLotService {
- private final Map<Size, Deque<Spot>> free = new EnumMap<>(Size.class);
- public Ticket park(Vehicle v) {
- Spot spot = free.get(v.size()).pollFirst();
- if (spot == null) throw new LotFullException(v);
- return new Ticket(spot, v, clock.instant());
- }
- static class Bus extends Vehicle {
- Bus() { super(Size.LARGE, 5); }
- }
- }
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.
The interviewer asks
- What does the strategy interface take and return?
- Who owns the free-spot state - the strategy or the level?
- 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.
- tryConsume(int tokens)boolean
- refillTokens()void
- getAvailableTokens()int
1package com.meritello.ratelimiter;23public class RateLimiter {4 private final int capacity;5 private final AtomicInteger currentTokens;67 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}
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.
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
Told as "we" throughout. The rate limit at the gateway was the key call - whose was it?
“What did you personally decide in the first ten minutes, and what did you leave to the team?”
“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.”
- –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 roundTransparency 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
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.
“Candidate noted: ‘I will assume only one car parks at a time for now.’ Interviewer followed up on thread safety.”
Line 14 in ParkingLotService.java lacked synchronization lock.
Recommended Next Practice Drill
Practice: “Thread-Safe In-Memory Key-Value Store with TTL” (Targeting Concurrency)
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.
Practice
Work on algorithmic invariants, OOP patterns, and system design canvases.
Interview
Take a realistic, voice-driven mock session with adaptive follow-ups.
Evidence
Every utterance, keystroke, and test result is logged into an objective record.
Feedback
Receive clear, timestamped observations tied to pre-published rubrics.
Improvement
Turn identified gaps into tailored practice drills in your candidate dashboard.
Practice Again
Return to the arena with measurable progress and renewed confidence.
Candidate Plans
Free during beta. Fair forever.
We believe nobody should be filtered out because they could not afford realistic interview practice.
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
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
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.
Build better interviews.
Practice with structure. Hire with evidence.