Mentoring and Coaching Questions
Growing individual engineers and teammates through one-on-ones, coaching conversations, and hands-on technical mentorship. Covers tailoring guidance to the person, coaching versus telling, unblocking and stretching people, and measuring the impact of mentorship on someone's growth. The single largest behavioral cluster in the category.
Walk me through a time you coached someone whose performance was genuinely below the bar. How did you approach the conversations, and how did it turn out?
Sample Answer
Direct answer
Coaching a genuine underperformer starts with diagnosing why (skill gap, unclear expectations, motivation, or something outside work like a health or personal issue) before assuming it's a will problem, then moving to a private, honest conversation with specific examples, a written and time-bound improvement plan with objective checkpoints, and a clear, stated understanding of what happens if the bar still isn't met. The hard part isn't the first conversation, it's staying honest and consistent through every checkpoint after it.
Structured elaboration
Diagnose before you coach
Below-the-bar performance has different root causes that call for different responses:
- Skill gap: they don't yet know how to do the thing. Response: targeted teaching, pairing, smaller scoped tasks.
- Unclear expectations: they don't know what "good" looks like here. Response: make the bar explicit and concrete, with examples.
- Motivation or engagement: they can do it but aren't. Response: a more direct conversation about what's changed and why.
- Something outside work: a health issue, a personal crisis, burnout. A private, non-judgmental check-in on wellbeing belongs early in this process, both because it's the right thing to do and because it changes what the right intervention is (support and possibly a formal accommodation, not a performance plan).
Getting this wrong (coaching a skill gap like it's a motivation problem, or the reverse) wastes the improvement window on the wrong intervention.
The conversation and the plan
- Deliver the message privately, plainly, and with specific examples: what's below the bar, what the bar actually is, and why it matters.
- Put the plan in writing: two or three concrete, observable goals, a defined timeframe, and what evidence would count as "met."
- Set a regular check-in cadence shorter than your normal 1:1 rhythm; below-the-bar performance needs tighter feedback loops, not the same cadence as everyone else.
When to involve HR formally
This is a judgment call many candidates get wrong by either never mentioning HR (naive) or looping HR in immediately (overcautious, and it can undermine trust). A reasonable line: loop in HR or your manager as soon as the conversation could plausibly lead to a formal employment outcome (a documented warning, or separation), even if you're optimistic it won't get there, because that's exactly when documentation and process need to be right from the start rather than reconstructed after the fact.
Protecting the team
The rest of the team usually already knows something is off; silence reads as either denial or unfairness. Without disclosing private performance details, it's reasonable to acknowledge you're aware of the gap and are addressing it, and to be transparent about redistributing work if needed, so the team doesn't quietly conclude the issue is being ignored.
Worked example
Situation
An engineer on a team I was supporting had been reliably strong for over a year, then their output quality and delivery reliability dropped off sharply over a couple of months: reviews were taking longer, deadlines were slipping, and the pattern didn't match a normal bad sprint.
Diagnosis
Before assuming a motivation problem, I had a private, low-pressure conversation focused on checking in rather than accusing. That surfaced that part of the issue was a skill gap on a newer part of the codebase they'd been assigned to without much ramp-up, but there was also something going on outside work affecting their focus.
Action
We set a short, explicit improvement plan: two concrete, observable goals tied to real upcoming work, a shorter check-in cadence, and pairing time on the unfamiliar codebase area. I also made sure they knew about the option to talk to HR about support resources for the personal situation, kept separate from the performance conversation so the two didn't get conflated.
Result
Performance recovered within the plan's window once the skill gap closed and the external situation stabilized. Because the conversation started from genuine diagnosis rather than an assumption, the plan addressed the actual cause instead of just adding pressure, and the person stayed on the team and rebuilt trust with the group.
The other branch (when it doesn't turn around)
Not every case ends this way. When someone doesn't meet a documented plan's criteria despite real support, the path is a harder, well-documented conversation, formal HR involvement, and eventually separation if there's no path forward. The mentor's job at that point shifts from "close the gap" to making sure the process is fair, well-documented, and handled with dignity, and to being honest with the rest of the team (without violating privacy) that a change is coming so it doesn't land as a surprise.
Trade-offs & pitfalls
- Treating every case as a motivation problem. The single biggest junior mistake here is skipping diagnosis and going straight to "try harder" messaging, which fails skill-gap and external-cause cases and can be actively harmful if there's something like burnout or a health issue underneath.
- Involving HR too late (or too early). Too late, and you've lost the documentation trail that protects everyone, including the underperformer, if it does become formal. Too early or too visibly, and it can read as punitive before the person's had a real chance, damaging trust unnecessarily.
- Optimizing for the individual at the team's expense, or the reverse. A senior answer holds both: real support for the person, and honesty with the team about workload and timeline impact, rather than pretending nothing's happening.
- No exit criteria stated up front. A plan without a clear "what does not-met look like, and what happens then" isn't actually a plan, it's a delay, and it's unfair to the person because they don't know what they're actually being measured against.
Set two SMART goals with someone you're mentoring who needs to grow in a specific area of their job. Walk through how you picked those goals and how you'd know they'd been met.
Sample Answer
Direct answer
Two well-chosen SMART goals for a mentee should target different dimensions, not two flavors of the same gap, typically one concrete skill or output gap and one behavioral or collaboration gap, each tied to real upcoming work (not an abstract exercise) with a defined timeframe and a way to verify progress that isn't just your own impression.
Structured elaboration
Picking the goals
- Start from an actual observed gap, not a generic template. Watch the person's real work for a pattern (recurring rework in reviews, difficulty scoping ambiguous tasks, avoiding certain kinds of conversations) rather than picking goals off a checklist.
- Pick goals from different dimensions on purpose. Two goals that are both "write better code" don't cover as much ground as one technical goal and one collaboration or communication goal; below-the-bar performance and stalled growth are rarely single-dimensional.
- Anchor each goal to real, upcoming work rather than an artificial exercise, so achieving it has actual value beyond the goal itself.
Making them SMART without making them hollow
- Specific: named against a real, current gap, not a generic aspiration ("get better at code review" is weak; "flag the two or three highest-risk issues in a review instead of commenting on every minor style choice" is usable).
- Measurable: defined by evidence you can point to later, not a feeling. This doesn't require an invented precision metric; "the last three reviews they gave focused on real risk rather than style nits" is legitimate evidence.
- Achievable: a real stretch, not guaranteed, but genuinely possible in the timeframe given their current level.
- Relevant: tied to what actually matters for their next step, not an arbitrary skill.
- Time-bound: a defined window, short enough to check in on meaningfully, long enough for real practice to happen.
Verifying they were met
Verification should come from something observable in the work itself, ideally corroborated by someone other than just you (a peer's comment, a second reviewer's read), not solely your own subjective sense that things feel better.
Worked example
Situation
A mentee was technically solid but had two recurring gaps: their code reviews tended to focus on minor style points while missing the real risk in a change, and they rarely spoke up in group design discussions even when they clearly had a relevant opinion afterward.
The two goals
- Review focus: over the next 6 weeks, shift their code review comments toward flagging genuine risk (correctness, edge cases, design concerns) rather than style, verified by a second reviewer independently agreeing their flagged issues were the real risk areas in at least the majority of reviews they gave in that window.
- Speaking up in design discussions: over the next 8 weeks, raise at least one substantive point live in a design discussion, rather than only afterward privately, verified simply by whether it happened and by a peer noticing the shift unprompted.
Why these two, not two code-quality goals
Picking a technical goal and a behavioral goal together addressed two independent gaps at once, rather than doubling down on the dimension that was already their relative strength.
Result
Both goals gave something concrete to check in on during regular 1:1s, and both had a verification method that didn't rely purely on my own impression, which mattered for making the conversation feel objective rather than a subjective judgment.
Trade-offs & pitfalls
- Goals that sound measurable but aren't actually verifiable. "Be more proactive" dressed up with a number attached is still not a real SMART goal if there's no real way to check it.
- Two goals in the same dimension. Picking two technical goals, or two soft-skill goals, leaves a real gap uncovered and wastes the opportunity a second goal represents.
- Goals set without the mentee's buy-in. A goal the mentee didn't help shape, or doesn't actually agree reflects a real gap, is much less likely to stick, even if it's technically well-formed.
- No connection to real work. An artificial exercise goal ("complete this course") is weaker evidence of growth than a goal embedded in work they were doing anyway.
A key person on your team is leaving in a few months and takes a lot of institutional knowledge with them. What would you actually do, as their mentor or mentee, to transfer that knowledge before they go?
Sample Answer
Direct answer
Treat it as an active transfer project with an owner and a deadline, not passive documentation. Inventory what this person uniquely holds, rank it by risk rather than by how interesting it is to write up, transfer the highest-risk pieces through hands-on shadowing rather than just writing, and verify the transfer actually worked by having the successor perform the task for real while there's still time to catch gaps.
Transfer approach
Inventory and rank by risk, not by volume. List what this person actually holds that nobody else can currently do, then rank by what breaks or stalls if it disappears, not by what's easiest or most interesting to document. A fixed departure date means you can't transfer everything equally; risk ranking tells you where to spend the limited time.
Match the transfer method to the kind of knowledge. Procedural and tacit knowledge, how to actually make a judgment call under pressure, how to run something that doesn't go by the book, transfers best through shadowing and pairing, not documents. Declarative knowledge, why a past decision was made, historical context, transfers fine through writing, since there's no live judgment being exercised.
Verify the transfer actually happened, don't assume it. Have the successor perform the highest-risk task for real, a supervised dry run or an actual live instance, while the departing person is still around to catch what's missing. "They read the doc" is not verification.
Build in redundancy, not just a single successor. Naming one person as the new holder of the knowledge just recreates the same single point of failure with a different name on it.
Sequence by time pressure. The runway is fixed and shrinking, so the highest-risk items go first, even if lower-risk items would be quicker or more satisfying to knock out.
Worked example
Someone with deep knowledge of a specific system announces they're leaving in a few months. You inventory what they uniquely hold and rank it by risk: the thing that would cause the most damage if nobody understood it isn't the thing that's easiest to write a doc about, it's a judgment-heavy process that only they've ever run. You assign a primary and a backup successor rather than just one person. For that highest-risk item, instead of relying on a runbook, you have the successor run it for real under supervision before the departure date. During that supervised run, a real gap surfaces, a step the departing person did automatically and never thought to write down, and it gets caught and fixed while there's still time, instead of surfacing for the first time after they're gone.
Trade-offs and pitfalls
A knowledge-dump documentation sprint feels productive but is rarely sufficient on its own. What the departing person chooses to write down reflects what they consciously think matters, filtered through their own blind spots; the things that are automatic to them are exactly the things they won't think to write down.
Waiting until the final weeks to start is a common and costly mistake. Tacit knowledge transfer through shadowing takes real elapsed time to work, so it needs to front-load into the runway, not compress into the last stretch.
Verifying through a real supervised run costs more time, and carries some real risk, compared to just trusting a document. That cost is worth it, because it's the only way to catch a gap before it becomes expensive, rather than after.
Naming a single successor and calling the transfer complete just recreates the original risk with a new name attached. The goal isn't a new single point of failure; it's genuine redundancy.
You have a recurring 30-minute one-on-one with someone you mentor. Walk through how you'd structure the agenda to balance day-to-day blockers, skill development, and career conversation, and how that structure should evolve over a quarter.
Sample Answer
Direct answer
A recurring 30-minute 1:1 works best with a light, predictable structure (a quick check-in, blockers, a skill or growth item, and a career or forward-looking question), but the real skill is protecting the last two from being crowded out by whatever operational fire is loudest that week, and shifting the balance of the agenda as the relationship matures over the quarter.
Structured elaboration
A default structure for 30 minutes
| Segment | Rough time | Purpose |
|---|---|---|
| Check-in | 3-5 min | Surface anything urgent, gauge how they're actually doing |
| Blockers / operational | 8-10 min | Whatever's actively in their way right now |
| Skill or growth item | 8-10 min | One concrete thing they're building toward, not a status update |
| Forward-looking / career | 5-7 min | Where this is headed, not just what's happening this week |
Guarding against the common failure mode
A well-known failure pattern: the 1:1 happens reliably every week, on time, with all the segments technically present, but the career and growth segments become shallow ritual ("anything on your mind for growth?" "nope, all good") while blockers quietly eat the real time. The fix isn't just having a slot on the agenda, it's asking a specific, forward-looking question each cycle rather than an open-ended one, and being willing to occasionally protect that segment even when there's a real blocker competing for the time.
Diagnosing what's actually going on, not just tracking status
Part of the value of a recurring 1:1 is using it to figure out whether a struggle you're observing is a skill gap or a mindset or behavioral issue, because the two need different responses. Someone who's struggling because they don't yet know how needs teaching and practice; someone who's struggling because of avoidance, overconfidence, or a mismatch in how they're approaching the work needs a more direct conversation about the pattern itself, not more technical instruction. A 1:1 is a good place to probe for which one you're actually looking at before assuming.
An alternative structure for hands-on technical work
For roles where the most valuable use of the time is genuinely technical, a 1:1 doesn't have to follow the career-conversation template at all. Structuring it around live debugging together, walking through a real problem with explicit hypotheses ("I think it's X, here's how we'd check") and tracking which ones got ruled out, can be a more valuable use of 30 minutes than a generic status-and-goals agenda, especially early in a relationship when trust and technical credibility are still being built.
Evolving the structure over a quarter
- Early on, more of the time typically goes to blockers and establishing trust; the person needs to know the meeting is safe and useful before career conversations will be genuine rather than performative.
- As confidence builds, the balance should shift toward growth and forward-looking conversation, and the blockers segment should shrink because there's simply less friction to clear.
- If that shift isn't happening by mid-quarter, that's itself a signal worth naming directly rather than just continuing to run the same agenda.
Worked example
Situation
Early in a mentoring relationship, our 1:1s were almost entirely blockers: real, legitimate ones, but every week's slot filled up before we got near growth or career topics.
Action
I made an explicit change: reserved the last five minutes for a specific forward-looking question every time, stated as a fixed rule rather than something to get to if there was time, and moved lower-urgency blockers to async channels so they didn't have to consume the live time by default.
Result
By partway through the quarter, the ratio had genuinely shifted: blockers took less of the time because fewer new ones were coming up, and the growth and forward-looking segments started generating real, substantive conversation instead of the same shallow "all good" answer each week.
Trade-offs & pitfalls
- Mistaking a full agenda for a working one. Hitting every segment on the template doesn't mean the 1:1 is actually working if the career and growth segments are consistently shallow.
- Applying the same generic structure to a technical, debugging-heavy role. Forcing a career-conversation template onto a context where live technical problem-solving would be more valuable wastes the time on both sides.
- Not distinguishing skill gap from mindset issue. Responding to a mindset or behavioral pattern with more technical coaching, or the reverse, burns the time without addressing what's actually going on.
- Never revisiting the structure. A rigid agenda that never evolves as the mentee matures signals the relationship isn't actually progressing, even if the meeting keeps happening.
Design a 30-60-90 day onboarding plan for a new hire joining your team. What do you prioritize in each phase, and how do you know they're on track?
Sample Answer
Direct answer
A good 30-60-90 plan moves someone from learning the environment, to contributing under supervision, to owning outcomes independently, with the phase boundaries defined by demonstrated behavior (what they can do unsupervised) rather than by the calendar alone. Track it with a small number of concrete, visible outputs per phase so "on track" is something you can point to, not just a feeling.
The three phases, by what changes
- Days 1-30 (learn and observe): environment setup, codebase or domain orientation, shadowing, and one small real contribution rather than a toy task, so the first change is real but low-risk.
- Days 31-60 (contribute under guidance): own a medium-sized piece of work end to end with a mentor available for review and unblocking, not doing it alongside them line by line.
- Days 61-90 (own outcomes): lead something (a project, an on-call rotation, a smaller onboarding task for the next hire) with the mentor as a backstop, not a co-pilot.
How you know they're on track
- Define the signal per phase in advance, not retroactively: for phase 1, did they reproduce the environment and ship one small real change without major help; for phase 2, is their review feedback shrinking in volume and severity over successive changes; for phase 3, can they make a reasonable decision alone and only escalate the genuinely hard calls.
- Check in on cadence (weekly early on, less frequent later) rather than waiting for day 30, 60, or 90 to find out something drifted three weeks ago.
Adjusting the plan for real constraints
- Limited training resources: when there's no dedicated ramp-up bandwidth (no spare mentor hours, no formal training material), lean harder on asynchronous artifacts: written runbooks, recorded walkthroughs, a curated list of the most representative recent changes, and a lighter-touch weekly sync instead of daily pairing. The phases stay the same; what changes is how much is self-serve versus live.
- Cross-skill ramp: if someone hired primarily for one skill set is expected to also ship in an adjacent one by day 90 (for example, a backend-focused hire expected to ship frontend work), that adjacent skill needs its own explicit milestone inside the plan, not an assumption it'll happen by osmosis. Concretely: days 1-30 stays focused on their strong area to build early confidence and trust; days 31-60 introduces the adjacent skill on a small, well-scoped, low-risk piece with close review; days 61-90 has them own something end to end in the new area, even if smaller in scope than their core-skill ownership.
Worked example
For a new hire joining an established codebase with a small team and no dedicated onboarding budget (the limited-resources case), the 30-60-90 looked like: days 1-30, self-serve environment setup using a written runbook plus a single half-day pairing session, culminating in one small, real bug fix; days 31-60, ownership of one medium feature with async review as the main touchpoint, and a short weekly 15-minute sync instead of daily check-ins; days 61-90, the new hire wrote the onboarding runbook update for the next person, which served double duty as both a real deliverable and a check on whether they actually understood the system well enough to explain it. Being on track was tracked by a short checklist per phase (environment reproducible, first fix merged with normal review effort, feature shipped with review comments trending down) rather than a single blanket "how's it going" check-in.
Trade-offs and pitfalls
- Treating the day boundaries as fixed calendar dates rather than behavioral milestones creates false confidence; someone can hit day 60 without actually being ready for phase-3 ownership, and pushing them into it anyway sets them up to fail.
- Under-supporting the adjacent-skill ramp (assuming a backend engineer will "pick up" frontend without an explicit milestone) is a common way cross-skill onboarding quietly fails; it needs the same structure as the primary skill, just smaller in scope.
- Compressing the plan under limited training resources by cutting phase 1 short (rushing into real ownership before the environment and codebase are understood) trades a faster-looking ramp for more review overhead and rework later.
Unlock Full Question Bank
Get access to all 40 Mentoring and Coaching interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.