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:

  1. What went well since last time?
  2. Where are you stuck or unsure?
  3. What do you want to learn next?
  4. 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:

Staircase of four stages from small tickets to owning an area of the codebase
Each step adds ownership and removes a bit of hands-on support.
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.