top of page

The First 30 Days for a New Engineer — Mentoring Engineers, Part 1

Shift Quality Editorial
Oct 1
8 min read

Updated: Oct 4

Mentoring Engineers · Part 1

A senior engineer joins a platform team on a Monday. Her laptop arrives on Wednesday. Her access to the deployment tooling arrives the following Tuesday, after two tickets and a reminder. By the end of week two she has read a lot of wiki pages, sat in nine introductory meetings and shipped nothing. Her manager, asked how she's doing, says "settling in fine". She is quietly updating her CV, because everything about the first fortnight told her the team hadn't expected her.


Nobody on that team was careless. Each delay had a reasonable owner and a reasonable excuse. The problem was that nobody owned the first month as a piece of work with an outcome. Onboarding was a checklist of things to give her, not a plan for what she should be able to do.


The working claim for this part of the path: the first 30 days have three jobs, and a plan that only covers one of them fails quietly. A study of onboarding at Microsoft (Ju et al., 2021) interviewed 32 developers joining new teams and 15 engineering managers, and grouped the onboarding experience into three themes: learning, confidence and social interaction. Most onboarding plans are heavy on the first and leave the other two to chance. The steps below give each one an owner and a test.


Before you start


  • Find the last two people who joined your team, and ask each one privately what they wish had been ready on day one. Their answers are your real backlog.

  • Check how long it takes, today, to go from a fresh laptop to a running local build. If nobody knows, that's the first finding.

  • Decide who the buddy will be before you decide anything else. The rest of the plan depends on that person having time.


Step 1: Treat access and setup as a pre-start deliverable (15 min)


Everything the new engineer needs to touch on day one should be requested a week before they arrive: hardware, accounts, repository access, the deployment tooling, the on-call paging app in read-only mode. The fork here is ownership. "IT handles that" means nobody checks. Name one person, usually the manager, who confirms each item is working, not just requested.


The reason this matters isn't comfort. Waiting for access in week one teaches a new engineer that the team's systems are slow and that asking doesn't help. Those are exactly the habits you'll spend month three trying to undo.


Test you can run: time the path from "laptop out of the box" to "tests pass locally" yourself, on a clean machine, before the start date. If it takes more than half a day, fix the instructions before you fix anything else in this plan.


Step 2: Write the plan as outcomes, not activities (15 min)


A 30-60-90 plan that says "read the architecture docs" and "meet the team" can be completed without learning anything. Write each milestone as something the engineer will be able to do, and something you could observe.


Weak milestone (activity)

Strong milestone (outcome)

Read the service docs

Can explain, at a whiteboard, how a request flows through our three main services

Meet the team

Knows who to ask about billing, deploys and the data pipeline, without asking the manager

Shadow on-call

Has handled one low-severity page with a buddy watching

Get familiar with the codebase

Has merged five changes, at least one touching code outside our team's main service


Agree the plan with the engineer in their first week, not before. They'll know things about their own gaps that you can't.


Test you can run: read each line of your current plan and ask "how would I know this happened?" Any line you can only answer with "they'd tell me" is an activity. Rewrite it.


Step 3: Get one real change merged in week one (15 min)


The first merged change does three jobs at once. It proves the setup works end to end. It walks the engineer through review, CI and deployment while the stakes are tiny. And it is the first piece of evidence, for them, that they can contribute here.


Pick it in advance. It should be small, real and self-contained: a flaky test with a known cause, a confusing error message, a missing log line. Avoid "fix a typo in the README". It's too trivial to teach the deploy path, and new engineers can tell when they're being given busywork.


What comes after the first change is a choice most managers make without noticing. Ju et al. describe three task strategies they saw managers use: simple-complex (raise difficulty gradually), priority-first (take whatever is next on the backlog) and exploration-based (a loosely defined problem to investigate). Simple-complex protects confidence but takes longer to plan. Priority-first delivers value early but can land a hard task in week two. Exploration suits experienced hires who want ownership, and can leave a junior engineer without any small wins. Choose one on purpose, based on who you hired.


Test you can run: for your last hire, how many working days passed between their start date and their first merged change? Over five is a signal that setup or task selection failed, and it's worth finding out which.


Step 4: Give the buddy a job description and time (10 min)


In the Microsoft study, 14 of the 18 participants who had a mentor or "onboarding buddy" found them helpful, mostly because a peer lowers the cost of asking. What the study doesn't count is the buddy's time, and that's where buddying usually fails: a buddy who is "around for questions" is usually busy. Plan the time explicitly. A workable buddy brief:


  • A 15-minute check-in every day for the first two weeks, then twice a week.

  • First responder for questions the engineer feels awkward asking the manager.

  • Pairs on the first two changes (Part 2 covers how to make pairing teach).

  • Has their own sprint commitments reduced to make room. If they don't, the buddying is the first thing to go.


Test you can run: ask the buddy how many hours they spent on onboarding last week, and check that the number is visible in their sprint load. If the answer is "it's fine, I fit it in", they're doing it at night or not doing it.


Step 5: Build connection on purpose, especially when remote (10 min)


Learning the system is the part teams plan. Getting connected is the part they assume. Rodeghero et al. (2021) surveyed 267 new hires who onboarded to Microsoft software teams remotely during the pandemic, and found that building a social connection with the team was one of the biggest challenges. In an office, some of that happens by accident. Remotely, almost none of it does.


Spread introductions across the month, one or two a day, each with a reason: "Talk to Sam, he owns the billing service you'll touch in week three." Invite the new engineer into a real design discussion early, as a listener, so they hear how the team disagrees. Give them a channel or person where a "stupid question" costs nothing.


Test you can run: at day 15, ask the engineer to list who they'd go to for help on three different topics. If every answer is the buddy or the manager, the network hasn't formed yet.


Step 6: Expect low output, and measure the right thing (10 min)


Velocity in month one is low, and should be. What you can measure is whether learning and confidence are moving. Track three signals instead of story points: the size and scope of changes over time, the number of questions asked (rising early is good), and how much of each change needed rework in review.


The fork is what to do when a new engineer looks slow. The instinct is to give them easier work. Check first whether the setup or the codebase is the bottleneck, by asking what they spent yesterday doing. Often the answer is "fighting the test environment", and that's a team problem with a team fix.


Test you can run: compare the first and fourth merged changes. The fourth should be larger, touch more of the system, or need fewer review rounds. If none of those moved, talk to them about what's in the way.


Step 7: Run a 30-day retro and fix one thing for the next hire (10 min)


At day 30, hold a one-to-one with four questions: what was ready that helped, what was missing, what confused you longest, and what would you change for the next person. Take one answer and fix it before the next start date. The fixes compound: the setup gets faster, the first-task list gets better, and each hire inherits a slightly better month.


Test you can run: open your onboarding doc and check when it was last edited. If it hasn't changed since your last hire started, the retro isn't feeding back into anything.


Worked example: the access backlog (composite scenario)


A platform team at a mid-sized insurer hired three engineers in one quarter. The first, a senior engineer, waited eight working days for deploy access and merged her first change on day eleven. The team assumed she was slow to ramp.


At her 30-day retro, she listed every blocker with dates. The manager noticed that five of the eight lost days came from one access request that needed approval from a separate security group, which nobody had told her about. The team made three changes: the manager raised all access requests ten days before a start date, the setup guide got a "known waits" section, and the first task was pre-selected and pre-scoped.


The second hire merged a change on day three. The third merged on day two, and spent week one pairing instead of waiting. The lesson the team took away wasn't "onboarding matters". It was more specific: the first hire's month was spent waiting on a dependency no one had mapped, and the only person who could see it was the person being onboarded. Asking her, with dates, found it.


Trade-offs to make deliberately


Choice

You gain

You risk

Heavy structure (detailed day-by-day plan)

Nothing is forgotten; easier for a stretched team

Senior hires feel managed; the plan ignores what they already know

Light structure (outcomes only)

Room to follow their curiosity

Gaps appear exactly where no one thought to look

Real production work in week one

Fast confidence; tests the deploy path

Pressure, if the first task turns out bigger than scoped

Learning-only first fortnight

Lower stress

Confidence builds slowly, and the setup isn't tested until later


For most enterprise teams, outcomes-led structure plus one pre-scoped real task in week one is the right default. Adjust after asking the engineer, not before.


Common failure modes


  • Access requested on the start date. The first week becomes a lesson in waiting.

  • A plan made of activities. It can be completed in full by someone who learned nothing.

  • A buddy with no time carved out. The buddying quietly stops in week two.

  • Judging month one by output. You end up "fixing" a person when the setup was the problem.

  • No retro, or a retro that changes nothing. Every hire repeats the same month.


Final takeaway


The first month works when it's treated as a piece of work with three outcomes: the engineer can find their way around the system, has evidence they can contribute, and knows who to ask. Plan each one, give each one a test, and ask the new engineer where the plan broke. Your next action: before your next hire starts, time the clean-laptop-to-passing-tests path yourself and write down every wait you hit.


Sources


  • Ju, A., Sajnani, H., Kelly, S. and Herzig, K. (2021). A Case Study of Onboarding in Software Teams: Tasks and Strategies. Proceedings of the 43rd International Conference on Software Engineering (ICSE 2021). arXiv:2103.05055.

  • Rodeghero, P., Zimmermann, T., Houck, B. and Ford, D. (2021). Please Turn Your Cameras On: Remote Onboarding of Software Developers during a Pandemic. ICSE 2021, Software Engineering in Practice track. arXiv:2011.08130.

  • Bauer, T. N. (2010). Onboarding New Employees: Maximizing Success. SHRM Foundation Effective Practice Guidelines Series.



Continue the Mentoring Engineers path



Part of the Mentoring Engineers learning path. Related: Run Effective One-on-Ones · Building Engineering Culture, Not Just Process.

bottom of page