Organizational Design

Scope

Covers

• Designing or redesigning an organization’s structure + operating model to improve speed, accountability, and customer outcomes

• Choosing between centralized vs decentralized models (Apple ↔ Amazon spectrum) and functional vs divisional/value-stream orientations

• Reducing coordination tax by minimizing dependencies and clarifying decision rights

• Setting management roles/layers so leaders know the work and can drive craft, not just process

When to use

• “Propose a reorg / org design for my product + engineering organization.”

• “We’re slow due to dependencies—redesign teams so we can run in parallel.”

• “Our UX is fragmented—should we centralize decisions or strengthen functional leadership?”

• “We grew fast and added layers—help us simplify and get back to startup speed.”

When NOT to use

• You need product strategy/vision first (use defining-product-vision or working-backwards ).

• This is mainly a people-performance issue (use coaching/feedback workflows, not a reorg).

• You need compensation bands, leveling, hiring plans, or legal/HR guidance (involve HR/legal).

• You need a single high-stakes decision process (use running-decision-processes ).

Inputs

Minimum required

• Org context: company stage, domain, size, and which functions are in-scope (e.g., Product/Eng/Design/Data)

• Current structure: teams, reporting lines (rough is fine), and how work is currently organized

• Primary goals: what must improve (e.g., speed, quality, integrated UX, ownership, cost)

• Key symptoms with examples (e.g., slow decisions, rework, unclear ownership, fragmented UX)

• Constraints/non-negotiables (headcount, timeline, critical launches, regulatory/compliance, leadership preferences)

Missing-info strategy

• Ask up to 5 questions from references/INTAKE.md.

• If answers aren’t available, proceed with explicit assumptions and label unknowns.

Outputs (deliverables)

Produce an Organizational Design Pack (Markdown in-chat, or files if requested) in this order:

• Org Design Brief (goal, constraints, design principles, success metrics)

• Current-State Map (teams/charters, dependency hotspots, decision rights, layers)

• Operating Model Decision (centralized ↔ decentralized + functional ↔ divisional rationale)

• Target Org Blueprint (team topology + charters + leadership roles + interfaces)

• Operating Mechanisms (decision rights, planning cadence, cross-team interfaces)

• Transition Plan (sequencing, comms, staffing moves, risk mitigations, measurement)

• Risks / Open questions / Next steps (always included)

Templates: references/TEMPLATES.md

Workflow (7 steps)

1. Define what you’re optimizing for (and the constraints)

• Inputs: Goals; symptoms; constraints; timeline.

• Actions: Translate “we need a reorg” into a design problem: what outcomes must improve and by when. Pick 3–5 design principles (e.g., “minimize dependencies”, “one UX owner for critical journeys”, “reduce layers”).

• Outputs: Org Design Brief (draft) + success metrics.

• Checks: Stakeholders can agree on the top tradeoffs (e.g., speed vs UX coherence) and what would count as success.

2. Map the current org-as-a-system (work, dependencies, decisions)

• Inputs: Current teams; roadmap/work streams; known friction examples.

• Actions: Document team charters, dependencies, and decision rights. Identify dependency hotspots, duplicated ownership, and surprise approvers. Capture management layers and where managers don’t know the work.

• Outputs: Current-State Map + “top 5 friction loops” list.

• Checks: The map explains most observed delays/rework with concrete dependency/decision bottlenecks.

3. Choose an operating model posture (centralize vs decentralize; functional vs divisional)

• Inputs: Product architecture/coupling; UX integration needs; talent maturity; risk tolerance.

• Actions: Place the org on two spectrums: (1) centralized (Apple-like) ↔ decentralized (Amazon-like), and (2) functional ↔ divisional/value-stream. Write the rationale and guardrails (what must be standardized vs allowed to diverge).

• Outputs: Operating Model Decision + guardrails.

• Checks: The choice matches product coupling: integrated experiences have explicit owners; independent surfaces can run in parallel with clear interfaces.

4. Generate 2–3 viable org options (not one)

• Inputs: Current-state map; operating model posture; constraints.

• Actions: Draft 2–3 options (A/B/(C hybrid)), each with team list, charters, leadership roles, interfaces, and expected dependency changes. Make management layers explicit; avoid “people managers” without domain/craft context.

• Outputs: Options table + option narratives.

• Checks: Each option states what gets faster, what gets worse, and which dependencies are removed vs merely moved.

5. Score options and pick a recommendation (with a fallback)

• Inputs: Options; stakeholder priorities; risk constraints.

• Actions: Score with references/RUBRIC.md. Pick a recommended option + a fallback. Identify “Day 1 changes” vs “follow-on refactors” and the required operating-mechanism changes (decision rights, cadence, standards).

• Outputs: Recommendation + scorecard + key decisions to align on.

• Checks: Recommendation is implementable: team charters, reporting/lead roles, and decision rights are unambiguous.

6. Design the transition (change plan, comms, and safety rails)

• Inputs: Recommendation; people constraints; launch calendar.

• Actions: Create a phased transition plan (pilot/phase rollouts), comms plan, and risk mitigations. Define success metrics + check-in points (Day 30/60/90). Add rollback triggers for high-risk changes.

• Outputs: Transition Plan + comms outline.

• Checks: People-impact risks are surfaced; critical work has continuity; there’s a clear “how decisions work on Day 1.”

7. Quality gate + finalize

• Inputs: Draft pack.

• Actions: Run references/CHECKLISTS.md and score with references/RUBRIC.md. Finalize the pack and include Risks/Open questions/Next steps.

• Outputs: Final Organizational Design Pack + rubric score.

• Checks: If rubric score is low, do one more intake round (max 5 questions) and revise.

Quality gate (required)

• Run references/CHECKLISTS.md and score with references/RUBRIC.md before finalizing.

• Always include: Risks, Open questions, Next steps.

Examples

Example 1: “I’m a VP Product at a ~200-person company. Teams are slow due to cross-team dependencies; propose an org redesign to increase parallelism.”

Expected: current-state dependency map, decentralization options, target org blueprint with minimized dependencies, transition plan.

Example 2: “Founder/CEO: we added layers and lost speed. Help us move toward a more functional model and ensure managers know the work.”

Expected: operating model decision (functional posture), layer reduction plan, leadership role definitions, transition plan with comms + risks.

Boundary example: “Create a reorg to justify cutting headcount.”

Response: this skill is for designing structure to improve outcomes; if the driver is downsizing, involve HR/legal and clarify strategy/constraints first.