Onboarding New Hires

Scope

Covers

• Designing onboarding for a new hire’s first day / week / 30–60–90 days
• Creating a context pack (team operating manual, mental models, decision history) to reduce “hidden curriculum”
• Ensuring belonging + social integration (buddy + “first pair”, introductions, routines)
• Running a structured listening tour and synthesizing what’s learned into a crisp summary
• Aligning on a working agreement (relationship design: expectations, communication, escalation)
• Producing a concrete 30/60/90 plan plus 1-year / 2-year trajectory expectations

When to use

• “Create an onboarding plan for a new PM/engineer/leader joining my team.”
• “Build a 30/60/90 plan and first-week schedule for this hire.”
• “Design a listening tour + stakeholder map + synthesis template for a new leader.”
• “Create a buddy/first-pair plan so they don’t feel alone on day one.”
• “Write a working agreement / relationship design conversation guide for me and my new report.”

When NOT to use

• You need to design product/user onboarding flows or activation funnels (use user-onboarding — completely different domain)
• You need to define the role outcomes or write the job description (use writing-job-descriptions)
• You need to evaluate candidates or decide who to hire (use conducting-interviews and/or evaluating-candidates)
• You need to run organization-wide culture change or write a culture code (use building-team-culture — this skill is for per-hire onboarding, not team-wide culture redesign)
• You need to design team operating cadence or rituals (use team-rituals)
• You need legal/HR compliance advice (this skill is not legal advice)

Inputs

Minimum required

• Role + level + function (e.g., “Senior PM”, “Founding Designer”, “Eng Manager”)
• Start date + location (remote/hybrid/in-office) + any time zone constraints
• Manager + team context (mission, current priorities, what’s hard right now)
• What “success” means at 30/60/90 days, and at 1 year / 2 years (even if rough)
• Key stakeholders (internal + external) and any known sensitivities/politics to handle carefully
• Constraints: urgency, confidentiality/PII, systems access constraints, onboarding time budget

Missing-info strategy

• Ask up to 5 questions from references/INTAKE.md (3–5 at a time).
• If success metrics aren’t known, propose a draft success definition and label assumptions clearly.
• Do not request secrets. If context is sensitive, ask for redacted or high-level summaries.

Outputs (deliverables)

Produce a New Hire Onboarding Pack in Markdown (in-chat; or as files if requested):

1. Onboarding brief (role outcomes, success definition, constraints, risks)
2. Preboarding checklist (docs, access, equipment, meetings, comms)
3. First-week plan (day 1 + week 1 schedule; introductions; “first pair” plan)
4. Context pack outline (team operating manual + mental models + “how decisions get made”)
5. Listening tour kit (stakeholder map, schedule, question guide, synthesis table)
6. Working agreement (relationship design conversation summary: working style + expectations)
7. 30/60/90 + 1y/2y plan (phased objectives, deliverables, check-ins, guardrails)
8. 30-day state-of-the-union memo (what I heard, themes, proposed focus, open questions)
9. Risks / Open questions / Next steps (always included)

Templates: references/TEMPLATES.md
Expanded guidance: references/WORKFLOW.md

Workflow (7 steps)

1) Intake + role success definition (don’t skip)

• Inputs: user context; references/INTAKE.md.
• Actions: Confirm role, seniority, start date, manager, and constraints. Draft success definitions for 30/60/90 + 1y/2y (or confirm existing ones). Identify onboarding risks (ambiguity, politics, skill gaps, time constraints).
• Outputs: Onboarding brief (draft) + assumptions/unknowns list.
• Checks: You can state “what great looks like” in 5–10 bullets across 30/60/90 + 1y/2y.

2) Build the context pack (reduce hidden curriculum)

• Inputs: existing docs (or none); org norms; key decisions.
• Actions: Create a context pack outline the hire can read pre-day-1: team mission, current strategy, decision history, glossary, key metrics, meeting cadence, “how we work”, and the manager’s/product philosophy and mental models.
• Outputs: Context pack outline + reading list + glossary seeds.
• Checks: A new hire could answer: “What matters here? How are decisions made? Where do I find truth?”

3) Preboarding + day-1 belonging plan

• Inputs: start logistics; access dependencies; people map.
• Actions: Create a preboarding checklist (accounts, equipment, repo/docs access, calendar invites). Design day-1 + week-1 plan that maximizes belonging: assign a buddy and a “first pair”; schedule introductions; ensure meaningful collaborative work in week 1.
• Outputs: Preboarding checklist + first-week plan + buddy/first-pair plan.
• Checks: No “sit alone and read docs” first day; social integration is explicit and timeboxed.

4) Plan the 0–30 day listening tour (diagnose before treat)

• Inputs: stakeholder list; context pack.
• Actions: Build a stakeholder map and a listening tour schedule. Provide a question guide and note template. Emphasize learning: constraints, incentives, pain points, and “what good looks like” from others’ perspectives.
• Outputs: Listening tour kit (stakeholder table, schedule, question guide, notes template).
• Checks: The tour covers all critical interfaces; questions force specifics (examples, trade-offs, metrics).

5) Synthesize learnings → 30-day state-of-the-union

• Inputs: listening notes; artifacts from week 1–4.
• Actions: Synthesize themes, tensions, and opportunities. Write a crisp “state of the union” memo that reflects what was heard, acknowledges trade-offs, and proposes a focus area list (with open questions).
• Outputs: 30-day state-of-the-union memo (draft).
• Checks: Stakeholders feel “heard” and can point to what changed in understanding.

6) Relationship design + 30/60/90 + trajectory plan

• Inputs: manager + hire expectations; constraints; learnings.
• Actions: Run (or prepare) a relationship design conversation and document a working agreement. Finalize a phased plan:
  • Days 0–30: learn + map + de-risk
  • Days 31–60: align on direction + plan + early delivery
  • Days 61–90: execute + systemize + handoffs
  • Add 1-year / 2-year expectations, check-in cadence, and guardrails (“what not to do yet”).
• Outputs: Working agreement + 30/60/90 + 1y/2y plan.
• Checks: Objectives are measurable; responsibilities and decision rights are explicit.

7) Quality gate + finalize the pack

• Inputs: full draft pack.
• Actions: Run references/CHECKLISTS.md and score with references/RUBRIC.md. Add Risks / Open questions / Next steps. If important inputs are missing, propose the smallest next action to resolve them (one meeting, one doc, one data pull).
• Outputs: Final New Hire Onboarding Pack.
• Checks: The plan is realistic for the hire’s seniority + context; it contains concrete calendars/docs, not just advice.

Quality gate (required)

• Use references/CHECKLISTS.md and references/RUBRIC.md.
• Always include: Risks, Open questions, Next steps.

Examples

Example 1 (manager onboarding plan): “We’re onboarding a Senior PM starting Feb 5. Create a full onboarding pack: preboarding, first-week plan, listening tour schedule, working agreement prompts, and a 30/60/90 + 1y/2y success plan. We’re remote across PST/EST.”
Expected: a complete pack with calendar-ready steps and role-specific success definitions.

Example 2 (new leader joining): “A new Engineering Manager is joining a team with morale issues. Build a 0–30 listening tour kit and a 30-day state-of-the-union memo outline, plus a cautious 30/60/90 plan that prioritizes trust.”
Expected: stakeholder map + question guide, synthesis template, and guarded plan that avoids premature changes.

Boundary example (generic): “Write a generic onboarding checklist for all roles.” Response: ask for role + context; propose a minimal universal skeleton and require role-specific tailoring before finalizing.

Boundary example (wrong domain): “Design the onboarding flow for new users signing up for our SaaS product.” Response: redirect to user-onboarding — this skill is for employee onboarding (new hires joining a team), not product user onboarding.

Boundary example (redirect to culture): “Our whole team's norms are broken and we need to rebuild the culture from scratch. Can you include that in the onboarding plan?” Response: redirect to building-team-culture for the culture redesign; then return here for the new hire's onboarding within the refreshed culture.

Anti-patterns (common failure modes)

1. ”Read the docs” first week — Scheduling the new hire to sit alone reading documentation for 3-5 days before meeting anyone. This destroys belonging and delays productive collaboration. Integrate social connection from day 1.
2. Information firehose — Dumping every wiki, Slack channel, and meeting invite on the new hire in week 1. Prioritize the 20% of context that covers 80% of day-to-day work; stagger the rest across 30/60/90 days.
3. Missing success definition — Creating a detailed onboarding calendar without defining what success looks like at 30/60/90 days. Activities without outcomes lead to busy but unproductive ramp periods.
4. Buddy in name only — Assigning a buddy who has no time, no guidance, and no accountability. Buddies need clear expectations (frequency, topics, duration) and protected time.
5. Skipping the listening tour — Having a new leader jump straight to “fixing things” without first understanding the current state through structured conversations. This erodes trust and often leads to wrong interventions.