New Engineer Onboarding Checklist

A 90-day onboarding workflow for a new software engineer, run by the hiring manager and a tech-lead mentor. Covers pre-arrival provisioning, Day 1 orientation, dev-environment setup, first-week engineering ramp, and 30/60/90-day milestones.

5 sections 21 steps Collects data
1

Pre-Day-1 Setup

  1. Provision SSO and SaaS accounts
    • IT creates the Okta / Google Workspace identity, then provisions GitHub org membership, AWS SSO, Slack, Jira / Linear, PagerDuty, Datadog, and 1Password through SCIM where possible. Confirm the GitHub team grants the right CODEOWNERS coverage for the engineer's pod — wrong team membership is the most common Day-1 access blocker.

  2. Ship the laptop with the team base image
    • Ship the MDM-enrolled laptop (Jamf / Kandji for macOS, Intune for Windows) with disk encryption, the team's standard browser profile, and the VPN client preinstalled. Include a printed Day-1 setup card so the engineer doesn't waste their first morning hunting for the wifi password.

  3. Confirm the engineer's track and pod assignment
    • Lock the engineer's track before Day 1 — it drives which repo they clone first, which mentor they get, and whether they need mobile-specific tooling (Xcode, Android Studio) or platform tooling (Terraform, kubectl) on their machine.

    Collects list
2

Day 1 Orientation

  1. Walk through mission and engineering values
    • The engineering manager covers the company mission, the engineering org's principles (e.g., blameless post-mortems, trunk-based development, you-build-it-you-run-it), and how these show up in day-to-day decisions. Ground it in a recent example, not a slide deck.

  2. Introduce the new engineer to the pod
    • Run a 30-minute pod intro: who owns which services, who to ask about which subsystem, and where the standup / retro / planning ceremonies sit on the calendar. Schedule 1:1 coffees with each pod member across the first two weeks.

  3. Tour the service catalog in Backstage
    • Walk through the engineer's pod-owned services in Backstage (or your equivalent service catalog): repo links, on-call ownership, SLOs, runbooks, and dependency graph. New hires often try to read the entire monorepo on Day 1 — the catalog is the right entry point.

  4. Review on-call rotations and escalation paths
    • Cover the PagerDuty schedule, severity definitions (SEV1 / SEV2 / SEV3), the incident commander rotation, and how to declare an incident in #incidents. Confirm the engineer is NOT on the primary rotation until after the shadow shift in Week 1.

3

Development Environment

  1. Clone the monorepo and pass pre-commit hooks
    • Clone the primary repo, install language toolchains via asdf / mise, and run the bootstrap script. Confirm gitleaks / trufflehog pre-commit hooks fire on a deliberately committed dummy secret — this is the only way to know the secret-scanning gate actually works on this machine.

  2. Configure IDE with team lint and formatter rules
    • Install the team's recommended IDE extensions (ESLint, Prettier, Ruff, gopls, rust-analyzer — whichever the stack uses) and import the shared editor config. Format-on-save is non-negotiable; PRs that disagree with the formatter waste reviewer time.

  3. Connect to staging VPN and verify kubectl access
    • Connect to the staging VPN, run aws sso login, then verify kubectl get pods -n <pod-namespace> against the staging cluster. Production access is granted later, only after the engineer completes the access-review acknowledgment.

  4. Boot the local docker-compose stack end to end
    • Bring up the full local stack via docker compose up, run the seed script, and exercise the smoke-test user path against localhost. Local-stack failures on a new machine are usually Docker memory limits, port collisions with another running service, or stale env vars from a prior shell session.

    Collects list
  5. Pair with a platform engineer to debug the environment
    • Book a 60-minute pairing slot with a platform engineer to walk through the failing services. File a ticket against the dev-environment repo with the reproduction steps so the next hire doesn't hit the same wall.

4

First-Week Engineering Ramp

  1. Pair with the assigned mentor on a starter ticket
    • The mentor picks a starter ticket from the pod's backlog tagged good-first-issue — small scope, well-bounded, touches the build / test / deploy loop without requiring deep domain context. Pair on the first commit; the engineer drives, the mentor narrates the codebase.

  2. Open and merge the first production PR
    • Open a PR following the team's PR template (description, test plan, risk, rollback note). Get the CODEOWNERS-required approval, watch CI go green, squash-merge to main, and confirm the canary deploys cleanly. Goal is one shipped change in the first week — small, real, and visible in the changelog.

    Collects url
  3. Walk through the team code review checklist
    • Cover what the team looks for in review: PR size budget (target under 400 lines), test coverage on changed paths, observability for new code paths, backwards compatibility for API changes, and the migration-safety rules (no ALTER TABLE with default on hot tables, batched backfills only). "LGTM" without reading is the cultural failure to avoid.

  4. Shadow a primary on-call shift
    • Shadow the primary on-call for one full shift in PagerDuty's read-only mode. Observe how the on-call triages a page, navigates the runbook, drives an incident channel, and writes the handover note. The engineer joins the primary rotation only after a second shadow and explicit manager sign-off.

  5. Read the incident response runbook
    • Read the team's incident runbook end to end: declaring an incident, picking the IC and scribe, status-page updates, customer-comms coordination, and the blameless post-incident review template. Confirm the engineer can find the SEV1 hotline and the Statuspage admin in under 30 seconds.

5

30-60-90 Day Milestones

  1. Hold the 30-day check-in with the manager
    • Structured 30-day check-in: PR throughput, review participation, on-call readiness, pod-fit signals from peers, and any blockers (access, environment, scope clarity). The engineer also rates onboarding from their side — gaps surface fastest at this checkpoint.

    Collects list
  2. Build a 30-day remediation plan
    • The engineering manager and the engineer agree on a written remediation plan: two or three specific behaviors to change or skills to build, weekly 1:1s, and a 60-day reassessment. Loop in HR if the plan touches performance-management territory.

  3. Lead a self-contained project by Day 60
    • By Day 60 the engineer should own a scoped project end to end: design doc, implementation, review coordination, deploy, and post-launch monitoring. Pick something with a clear customer-visible or operational outcome — first PRs prove they can ship; a project proves they can drive.

  4. Conduct the 90-day growth-plan conversation
    • Close out onboarding with a 90-day review: collect peer feedback through the standard 360 template, confirm the engineer's growth areas for the next two quarters, and graduate them off the onboarding tracker. The mentor relationship can continue informally; the structured ramp ends here.

Use this template

Copy it to your account, customize the steps, and run it with your team in minutes.


Sections 5
Steps 21
Category Software Development
Price Free to start
Need a different process

Browse hundreds of free templates across every team and industry.

Back to template library

Run New Engineer Onboarding Checklist with your team

Customize the steps, assign roles, set a schedule, and keep a complete record for every run.