Practicing with a friend is the most underrated way to prepare for a coding interview. It's free, you can do it as often as you like, and a friend who already knows your weak spots can aim straight at them. The catch is that most people run a mock interview with a friend badly — they pick a softball problem, skip the timer, rescue each other at the first pause, and end with a vague "yeah, that was solid." That's not practice; that's hanging out with an editor open.
Done right, a mock interview with a friend beats almost every paid option, because the person across from you reacts to your reasoning in real time and pushes exactly where you need it. This is a step-by-step playbook for running one that actually moves the needle.
Why a friend works — and where it falls apart
A good mock reproduces the one thing solo practice can't: another person watching, asking questions, and judging how you think. A friend supplies that for free, on your schedule, as many times as you want — no stranger-matching, no booking, no cost.
The failure mode is comfort. Friends don't want to make you squirm, so they lob easy problems, jump in with hints the moment you go quiet, and soften their feedback. But the discomfort is the training. Before you start, agree out loud on one rule: for the next 45 minutes you're not friends, you're an interviewer and a candidate — and going easy helps no one.
Pick the right partner
Not every friend makes a good practice partner. Look for:
- Someone at or slightly above your level. They need to recognize a solid approach from a shaky one and call the difference.
- Someone who's also preparing. If you're both interviewing, every session pays off twice and neither of you resents the hour.
- Someone who'll be honest. The friend who tells you your explanation lost them at minute three is worth ten who say everything was great.
A mentor or a more senior engineer is ideal if you can get the time. But a peer grinding the same prep is often the most sustainable choice, because you can trade sessions for weeks without it feeling like a favor.
Take turns — being the interviewer makes you sharper
The best feature of practicing with a friend is reciprocity: you interview each other. Don't skip your turn on the other side of the table.
Playing interviewer teaches you what the role actually feels like — how obvious it is when a candidate goes silent, how much a clear plan up front reassures you, how a messy variable name makes you lose the thread. Once you've felt that from the interviewer's seat, you instinctively do the opposite as a candidate. An hour of interviewing your friend can lift your own performance as much as an hour of being interviewed.
Set up the room
The environment matters more than people expect. You want it to look like the real interview so none of your focus leaks into fighting the tools.
- Use a shared coding pad, not a screen-share. Both of you should see and edit the same code live, with the code actually running.
- Send an invite link. Your partner should join in seconds from any browser — no account, no setup friction.
- Turn the camera on and get on the same kind of call a real remote round would use.
- Keep the recording so you can review it afterward instead of relying on memory.
This is exactly what Codex Interview is built for: you open a live coding pad, send a link your friend opens in any browser, and every keystroke syncs instantly while you run JavaScript, Python, Java, C++, or Go right in the pad. It runs beside Zoom, Meet, or Teams, so a remote practice session looks just like a remote interview, and session playback lets you replay the whole room — code and chat — after it ends. If you want the mechanics, here's how Codex Interview works.
A 60-minute two-way session
Here's a repeatable shape that fits two full rounds and two debriefs into an hour:
- You interview your friend (25 min). Hand them one problem, start the timer, and sit on your hands for the first few minutes instead of hinting. Take notes on where they go quiet or thrash.
- Debrief them (5 min). Three concrete things, plus the first moment you got confused about their approach.
- Swap roles (25 min). They interview you with a different problem, same rules.
- Debrief you (5 min). Same format — three things, one confusing moment.
Hold the timer honestly; the pressure of a hard stop is part of what you're training for. For the detailed anatomy of a single round — clarify, plan, code, test, debrief — follow the structure in our guide to the mock coding interview. This playbook just runs that loop in both directions.
How to be a good interviewer for your friend
When it's your turn, your job is to be useful, not nice:
- Pick a real problem — ideally one you've actually been asked — not the first easy thing you remember.
- Don't rescue too early. Let them sit in being stuck for a minute; recovering from a dead end is a skill they need to rehearse.
- Ask "why" out loud. "Why a hash map here?" forces them to defend trade-offs the way a real interviewer will.
- Write down the moment you got lost. That's the single most valuable thing you'll hand back in the debrief.
If your friend is preparing for a collaborative format specifically, run it as pair programming interview practice — build something together in stages instead of watching them solo a puzzle.
No friend in tech? Here's the fallback
If nobody in your circle can play interviewer, you still have options:
- A mentor or senior colleague for a session or two — even one is worth a lot.
- Peer mock-interview platforms that pair you with a stranger for a timed round. Good for volume and for practicing with someone who doesn't know your habits.
- Solo reps to keep the raw problem-solving sharp between sessions.
Any of these works; the friend route just tends to be the most flexible and repeatable once you've found the right partner.
Common mistakes when practicing with a friend
The friend-specific traps, and how to dodge them:
- Softball problems. Pick something that would genuinely stump you, not a warm-up.
- No timer. Casual practice drifts into chatting; a hard stop keeps it honest.
- Hint-trigger fingers. Sitting quietly while your friend struggles is the hardest and most useful part of interviewing them.
- Vague feedback. "That was good" teaches nothing — force three concrete, testable items every time.
- Skipping your own turn. If you only ever get interviewed, you're leaving half the value on the table.
Turn practice into the real thing
A mock interview with a friend costs nothing and, run properly, out-trains most paid alternatives. Agree to drop the niceness for the length of the session, hold the timer, take turns, and hand each other three concrete things to fix. Do that five or six times and the real interview stops feeling like a performance.
Line up a partner, open your coding interview assistant, send the invite link, and run your first two-way session today.