DEV Community

Ashkan Rajaee
Ashkan Rajaee

Posted on

Onboarding a Developer to a Client Project So They Ship in Week One

Most developer onboarding on client projects looks the same. A new engineer joins on Monday. They spend the first day waiting for a laptop policy, a VPN account and repository access. The second day goes to reading a wiki that was last updated two releases ago. By Thursday they have sat through several meetings and changed nothing. The client is paying for that week, and the engineer is quietly wondering whether they made the right move.

Earlier in my career, as a partner, I helped grow a software consulting company from about $6M to $60M in under three years, and later I founded and ran a fully remote consultancy. When you are adding engineers to client work at that pace, a slow first week is not a small inefficiency. It is a cost the client sees, a risk to the relationship, and a bad first impression for someone you worked hard to hire.

The fix I trust is simple to describe and easy to skip: a first-week plan with access ready on day one, a named buddy, and one small real ticket shipped by day five. Here is the developer onboarding checklist behind it, and why each piece matters.

Why the First Week Decides More Than It Should

The first week sets the pattern. An engineer who ships something small in the first five days learns the codebase, the deploy path, the review culture and the people, all through one piece of real work. An engineer who spends the week reading and waiting learns that this project moves slowly and that nobody was ready for them.

The client notices too. On a client project, a new name on the team usually shows up somewhere the client can see: a standup, a status report, an invoice. If the first thing the client hears about that person is "still getting set up," you have spent trust you will need later.

None of this requires a heroic new hire. It requires the existing team to prepare before the person arrives.

Before Day One: Get Access Ready in Advance

Most lost first days are access problems. They are also the most preventable.

Before the engineer starts, someone on the existing team should own a short access list and confirm each item works, not just that a request was filed. On a typical client project that list includes:

  • Email or chat accounts on the client side, if the client requires them
  • Source control, with permission to open a branch and a pull request
  • The issue tracker, with the first ticket already assigned
  • A working local or cloud development environment, or clear steps that someone has run recently
  • Read access to the staging environment and logs
  • Any security training or agreements the client requires, scheduled before day one where possible

Client access often depends on people outside your team, so start early. If something cannot be ready, say so in advance and plan around it. A known gap is workable. Discovering gaps one by one is not.

A Named Buddy, Not a Shared Channel

"Ask in the team channel if you get stuck" sounds welcoming. In practice, a new person is reluctant to interrupt a busy channel with basic questions, so they guess, or they wait.

Assign one named buddy for the first two weeks. The buddy is not a manager. It is a peer on the same project who knows the code and the client, and who has agreed to be interrupted. Give them real time for it, and say so in the plan, so the buddy does not have to choose between helping and hitting their own deadlines.

The buddy's job is practical: pair on setup, walk through how a change reaches production, explain who on the client side cares about what, and review the first pull request.

The First-Week Plan, Day by Day

A plan does not need to be long. It needs to exist before the person arrives. A version that works for most client projects:

Day one. Confirm access, run the project locally, meet the buddy and the delivery lead. Read the one or two documents that actually matter: how the system fits together and how work gets done on this team. End the day with the first ticket open and understood.

Day two. Pair with the buddy on the ticket. Learn the branch, test and review conventions by doing them, not by reading about them.

Day three. Work on the ticket with less help. Join the client-facing standup or status meeting and listen for who decides what.

Day four. Open the pull request. Respond to review comments. This is where the engineer learns the team's real standards.

Day five. The change is merged and, where the project's release process allows, deployed. Hold a short end-of-week conversation: what was confusing, what was missing from the plan, and what the next two weeks look like.

Choosing the Right First Ticket

The first ticket is the heart of the plan, and it is easy to get wrong in both directions.

Too large, and the week turns into a struggle that ends with an unfinished branch. Too trivial, and the engineer fixes a typo without touching the parts of the system that matter. A good first ticket is small, real and visible: a minor bug a user or the client has noticed, a small improvement to an existing screen or endpoint, or a missing test around an area the team will work on soon. It should touch the normal path through the code, require a real review and go through the real deploy process.

Pick it before the engineer starts. Keep a short list of candidate tickets tagged for new joiners, so you are never choosing one in a hurry on Monday morning.

A Hypothetical Example

Here is a made-up scenario to show the difference. Two engineers of similar skill join two different client projects on the same Monday.

The first finds no repository access, a stale setup guide and a team channel to ask questions in. By Friday they have a working environment and a list of questions. The client's weekly report says the new engineer is "ramping up."

The second finds their access already working, a buddy on their calendar, and a small bug fix assigned. By Friday that fix is merged and in staging, and the client's weekly report mentions it by name. Same talent, same week, very different starting points.

What This Will Not Fix

A good first week does not replace a good hire. It will not make a weak fit succeed, and it does not end onboarding. Most engineers need several weeks to understand a client's domain well enough to make good judgment calls on their own. The goal of week one is narrower: prove that the path from ticket to production works for this person, and build the relationships that will carry the next month.

It also depends on the client. Some clients have security reviews that take longer than a week. In that case, plan the first ticket around what the engineer can access, and tell the client early how you are handling it.

Start With Your Next New Joiner

You do not need a new onboarding program to do this. Before the next engineer joins a client project, write a one-page first-week plan, confirm the access list item by item, name the buddy, and pick the first ticket. After their first week, ask them what was missing and add it to the page.

Onboarding a developer to a client project so they ship in week one is mostly preparation done by the people who are already there. When the team does that work, the new engineer becomes a contributor in days instead of a cost line for a month, and the client sees the difference right away.

If you are adding engineers to client work and want help building onboarding that gets them shipping in their first week, visit https://tdzpro.com.

Ashkan Rajaee is the founder of TDZ Pro. He has spent years building and scaling software engineering teams, including a fully remote software consultancy.

Top comments (0)