Mentoring is a big part of my job, and it's easy to get the amount wrong. Newer developers can stay stuck for days on something you could explain in minutes, or you can end up as a full-time help desk with no time for your own work.
At Squareflo I mentored frontend developers on React and our internal coding standards. This post covers the approach I use: a lot of structure at the start, then stepping back over time.
Step 1: Start with a Clear Onboarding Path
New developers lose the most time in their first few weeks, mostly to things nobody wrote down. A short onboarding path saves both of you hours:
- Setup guide: how to run the project locally, environment variables, test commands. Ask the new developer to fix anything that's outdated. It makes a good first contribution.
- Architecture overview: a one-page map of the main parts of the system and how they talk to each other.
- Team conventions: branching, commit messages, PR template, coding standards.
- A first task picked in advance: small, real, low-risk, and touching the main parts of the stack.
Tip
Keep a running "questions new developers ask" document. Every repeated question is a gap in your docs, and the next new hire gets the answer without asking.
Step 2: Set Expectations Early
Many newer developers are afraid of asking "stupid questions" or of wasting a senior's time. Others ask before trying anything. A simple, explicit rule helps both:
Try for 30 to 60 minutes. If you're still stuck, ask, and show me what you've tried.
It gets people to try things on their own first, and nobody stays stuck for a whole day. Tell them plainly that you expect them to ask.
Step 3: Hold Regular One-on-Ones
A short one-on-one (30 minutes weekly or every two weeks) does a lot of the work. Let them set the agenda, but keep a simple structure to fall back on:
- What went well since last time?
- Where are you stuck or unsure?
- What do you want to learn next?
- Feedback in both directions: what's working and what isn't.
Write down what you agree on and revisit it next time. Holding them regularly matters more than how long they run.
Step 4: Teach Through Questions
When a newer developer brings you a problem, the fastest response is to give the answer. It's also the one they learn the least from. Try guiding questions instead:
- "What do you expect this function to return here? What does it actually return?"
- "Where would you look first to see where this value changes?"
- "What happens if this API call fails?"
- "Is there anything similar elsewhere in the codebase we could follow?"
Over time they build a debugging process they can use on the next bug too.
Note
Use judgment. If there's a production incident or a deadline today, just help them fix it, then talk through the reasoning afterwards.
Step 5: Pair Program Deliberately
Pairing is the fastest way to transfer the knowledge that never makes it into docs: how you navigate a codebase, read error messages, use the debugger and decide what to try next.
What works for me:
- Let them drive (hold the keyboard) most of the time while you navigate.
- Think out loud when you drive, so they hear your reasoning as well as see the result.
- Keep sessions to around 60 to 90 minutes, with one clear goal.
- Pick tasks slightly above their current level, so they stretch without getting lost.
Step 6: Use Code Review as a Teaching Tool
Code review is mentoring too. For newer developers, explain the why behind every important comment, link to the relevant docs or examples, and mention what they did well.
Over time, stop pointing out every issue and ask them to check their own PR against a checklist before requesting your review. Later, have them review your pull requests too. Reading a more experienced engineer's code with a critical eye teaches a lot.
Step 7: Gradually Increase Ownership
You're aiming for someone who can work on their own. Increase responsibility step by step:
| Stage | What they own |
|---|---|
| Weeks 1–4 | Small, well-defined tickets with close support |
| Months 2–3 | Full features in a familiar area, with design reviewed before coding |
| Months 3–6 | A feature end to end: estimation, design, implementation, release |
| Beyond | A component or service area, plus helping onboard the next new developer |
The timeline varies by person, so adjust it to how they're progressing.
Warning
Owning a feature shouldn't mean working alone. Keep a short regular check-in so problems come up early, not the day before a deadline.
Step 8: Protect Your Own Time
Mentoring shouldn't mean being interrupted all day. A few boundaries help:
- Office hours: a fixed daily slot when anyone can drop in with questions.
- Ask people to post questions in a team channel rather than private messages, so the answers help everyone.
- If you explain something twice, write it up as a doc.
- Pair newer developers with each other and with mid-level engineers, so they aren't all coming to you.
Summary
Start with onboarding and clear expectations, then teach through one-on-ones, questions, pairing and code review, and hand over ownership step by step. You're done when they don't need you for day-to-day work.



