Software engineers love design patterns. Factory, Observer, Strategy—we have names for recurring solutions to recurring problems.

Management has patterns too. Not organizational structures or methodologies, but specific, repeatable practices that work across different contexts.

Here are patterns I’ve seen work in startups, scale-ups, and enterprises.

Pattern 1: The Written Decision Record

Intent: Make decisions visible, reversible, and learnable.

Context: Teams waste time relitigating old decisions, or worse, making decisions without knowing why previous choices were made.

Solution: Write down significant decisions in a standard format.

graph TD A[Decision Needed] --> B[Create Decision Record] B --> C[Document Context] C --> D[List Options] D --> E[Choose & Explain] E --> F[Record Date & Owner] F --> G[Store in Searchable Location] H[Future Question] --> I[Search Records] I --> J{Found?} J -->|Yes| K[Understand Why] J -->|No| L[Make New Record] style K fill:#9f9,stroke:#333,stroke-width:2px

The Format:

# Decision: [Title]

Date: 2025-01-15
Owner: [Who made the call]
Status: [Accepted / Deprecated / Superseded]

## Context
What was happening when we made this decision?

## Options Considered
1. Option A - [pros/cons]
2. Option B - [pros/cons]
3. Option C - [pros/cons]

## Decision
We chose [option] because [reasoning].

## Consequences
What became easier/harder because of this?

Real Example:

At Shopify, they documented the decision to build their own deployment system instead of using Kubernetes. When engineers asked “why aren’t we using K8s?” the answer wasn’t buried in someone’s memory—it was written down with the reasoning from 2018.

When context changed in 2023 (team grew, requirements shifted), they could reevaluate based on clear criteria.

Consequences:

  • Good: New hires ramp up faster, less repeated arguments
  • Bad: Writing takes time, records need maintenance
  • Neutral: Forces you to be honest about why you really chose something

Pattern 2: The Escalation Tax

Intent: Keep decisions at the lowest competent level.

Context: Teams ask managers for permission on things they could decide themselves, creating bottlenecks and dependency.

Solution: Make escalation slightly more expensive than deciding yourself.

The Rule:

If you escalate a decision to your manager, you must provide:

  1. Clear description of the problem
  2. At least two viable options
  3. Your recommendation with reasoning
  4. What you need from them specifically

Conversation Flow:

sequenceDiagram participant E as Engineer participant M as Manager E->>M: "Should we use Redis or Memcached?" M->>E: "What's your recommendation?" E->>M: "Not sure, that's why I'm asking" M->>E: "Come back with your analysis and I'll help" Note over E: Researches options E->>M: Here's my analysis: [detailed writeup] E->>M: I recommend Redis because [reasons] E->>M: I need you to confirm this won't conflict with [thing] M->>E: Confirmed. One concern: [specific thing]. Can you address? E->>M: Yes, here's how: [answer] M->>E: Go ahead.

Real Example:

At Amazon, the “two-way door” concept is similar. Reversible decisions (two-way doors) should be made quickly by individuals. Irreversible decisions (one-way doors) require more process.

Consequences:

  • Good: Develops judgment, increases velocity
  • Bad: Feels harsh initially, requires manager discipline
  • Neutral: Shifts time from answering questions to reviewing proposals

Pattern 3: The Directly Responsible Individual (DRI)

Intent: Eliminate confusion about who’s accountable.

Context: Group ownership means no ownership. When everyone is responsible, no one is.

Solution: For every project, one person is the DRI. They don’t do all the work—they’re accountable for the outcome.

The Model:

graph TB DRI[DRI: Alice] --> D[Makes Final Decisions] DRI --> C[Coordinates Work] DRI --> A[Accountable for Results] T1[Backend Team] -.->|Contributes| DRI T2[Frontend Team] -.->|Contributes| DRI T3[Design Team] -.->|Contributes| DRI DRI --> R[Results] style DRI fill:#f9f,stroke:#333,stroke-width:4px

The Rights and Responsibilities:

The DRI can:

  • Make final calls on scope, timeline, and approach
  • Pull in resources they need
  • Say no to feature requests
  • Change course if needed

The DRI must:

  • Communicate status clearly
  • Deliver the outcome (or escalate early if at risk)
  • Coordinate across teams
  • Own the result, good or bad

Real Example:

Apple uses this rigorously. Every meeting has a DRI. Every feature has a DRI. When iOS bugs appear, there’s a specific person whose name is next to it.

This doesn’t mean they fix it themselves—but they ensure it gets fixed.

Consequences:

  • Good: Crystal-clear accountability, faster decisions
  • Bad: Requires mature individuals, can feel like a lot of pressure
  • Neutral: Makes performance reviews much easier

Pattern 4: The Five-Minute Standup

Intent: Share status without derailing everyone’s day.

Context: Daily standups balloon to 30+ minutes of detailed discussions that only concern 2 people.

Solution: Strict time-box with a simple format.

The Rules:

  1. 5 minutes total, not per person
  2. Each person shares 3 things:
    • What I shipped yesterday
    • What I’m shipping today
    • What’s blocking me
  3. No discussion in the standup
  4. “Take it offline” is the most used phrase
graph LR A[5-Min Standup] --> B[Quick Status] B --> C{Blockers?} C -->|Yes| D["Note blocker, take offline"] C -->|No| E[Done] D --> F[Async Discussion After] D --> G[Scheduled Follow-up] style A fill:#9ff,stroke:#333,stroke-width:2px

Real Example:

A 15-person team at Intercom was spending 45 minutes in standups. They switched to:

  • Async written updates in Slack
  • 5-minute sync standup only for blockers
  • Deep dives scheduled separately

Result: 40 minutes back per day, better information flow.

Consequences:

  • Good: Respects everyone’s time, surfaces blockers quickly
  • Bad: Requires discipline, feels rushed at first
  • Neutral: Moves problem-solving to appropriate forums

Pattern 5: The Fix-It Week

Intent: Prevent technical debt from becoming technical bankruptcy.

Context: Teams always prioritize features over maintenance, until the codebase becomes unmaintainable.

Solution: Every quarter, one week is dedicated to fixing things that bother you.

The Structure:

gantt title Quarterly Rhythm dateFormat YYYY-MM-DD section Q1 Feature Development :2025-01-01, 11w Fix-It Week :2025-03-17, 1w Planning Week :2025-03-24, 1w

The Rules:

  1. No new features during Fix-It Week
  2. Anyone can propose fixes (add them to a shared list throughout the quarter)
  3. Teams self-organize around what they want to fix
  4. Demo day at the end to show what improved

What Gets Fixed:

  • That flaky test everyone ignores
  • The slow query that makes deploys nervous
  • The onboarding doc that’s 2 years out of date
  • The build process that takes 45 minutes
  • The monitoring gap for the payment system

Real Example:

LinkedIn runs “InDay” once a month—a full day for engineers to work on whatever they want, often technical debt or tooling improvements.

Yammer (acquired by Microsoft) did quarterly hack weeks that had a similar effect.

Consequences:

  • Good: Morale boost, compounding quality improvements
  • Bad: Features ship slower, requires buy-in from product
  • Neutral: Makes technical debt visible

Pattern 6: The Spike Time-Box

Intent: Prevent research and prototyping from becoming endless explorations.

Context: “Let me investigate this” often means weeks of exploration with no clear outcome.

Solution: Research tasks get a fixed time budget and a clear deliverable.

The Format:

graph TD A[Question or Uncertainty] --> B[Define Spike] B --> C[Time-Box: 2-3 Days] B --> D[Clear Deliverable] D --> E[Document with Recommendation] C --> F[Investigation] F --> G{Time Up?} G -->|Yes| H[Deliver Findings] G -->|No| F H --> I{Should We Proceed?} I -->|Yes| J[Convert to Project] I -->|No| K[Document & Close] style H fill:#ff9,stroke:#333,stroke-width:2px

Example Spike:

Task: “Investigate whether we should migrate from REST to GraphQL”

Time-box: 3 days

Deliverable:

  • Proof-of-concept of 2-3 endpoints in GraphQL
  • Performance comparison
  • Developer experience assessment
  • Recommendation: Yes/No/Maybe with reasoning

Real Example:

Pivotal Labs (creators of Pivotal Tracker) formalized the “spike” as a first-class work item. Spikes have points, acceptance criteria, and demos—just like features.

The acceptance criteria is always: “We know enough to make a decision.”

Consequences:

  • Good: Research has clear boundaries, prevents rabbit holes
  • Bad: Sometimes you need more time and have to do another spike
  • Neutral: Forces clarity about what you’re trying to learn

Pattern 7: The Blameless Incident Review

Intent: Learn from failures without creating fear.

Context: When things go wrong, teams either hide problems or blame individuals, preventing real learning.

Solution: Structured postmortem focused on systems, not people.

The Process:

graph TB A[Incident Occurs] --> B[Create Timeline] B --> C[Identify Contributing Factors] C --> D[Ask 'Why' 5 Times] D --> E[Identify Action Items] E --> F[Assign Owners] F --> G[Share Widely] H[No Blame Rule] -.->|Enables| C I[Focus on Systems] -.->|Drives| D style G fill:#9f9,stroke:#333,stroke-width:2px

The Questions to Ask:

Not: “Who caused this?” But: “What conditions allowed this?”

Not: “Why didn’t you test this?” But: “What would have caught this in testing?”

Not: “You should have known better” But: “How can we make this knowledge accessible to everyone?”

Real Example:

When Google’s Gmail went down for 2.5 hours in 2020, their postmortem identified:

  • Configuration management processes
  • Monitoring gaps
  • Deployment safeguards needed

Not: “Bob deployed bad config”

Consequences:

  • Good: Psychological safety, actual learning, systems improvement
  • Bad: Feels uncomfortable if you’re used to blame culture
  • Neutral: Requires follow-through on action items

Pattern 8: The Office Hours Model

Intent: Provide access to expertise without constant interruptions.

Context: Senior people get interrupted constantly for help, breaking their focus.

Solution: Dedicated blocks for questions and pairing.

The Schedule:

Monday 2-4 PM: Office Hours (anyone can book 15-min slots)
Wednesday 3-4 PM: Drop-in (no booking, first-come first-served)
Other times: Focus work (emergency escalation only)

The Benefits:

graph TB A[Junior Engineer Has Question] --> B{Is it Urgent?} B -->|Yes| C[Slack immediately] B -->|No| D[Book Office Hours] D --> E[Prepare Question] E --> F[15-Min Session] F --> G[Get Answer + Context] H[Senior Engineer] --> I[Protected Focus Time] H --> J[Batched Helping] style I fill:#9f9,stroke:#333,stroke-width:2px style G fill:#9f9,stroke:#333,stroke-width:2px

Real Example:

At Stripe, staff engineers hold regular office hours. Junior engineers book time, come prepared, and get focused help.

The staff engineer gets uninterrupted time for deep work the rest of the week.

Consequences:

  • Good: Better help (prepared questions), protected focus time
  • Bad: Can feel less accessible initially
  • Neutral: Works best with async culture

The Anti-Pattern: Cargo Culting

The biggest management anti-pattern is copying practices without understanding why they work.

Examples:

  • Sprints aren’t magical. They force prioritization and create rhythm. If you do sprints but constantly adjust scope mid-sprint, you’ve lost the benefit.

  • Standups aren’t about attendance. They’re about surfacing blockers. If nothing ever changes based on standup info, stop doing them.

  • OKRs aren’t just goal-setting. They’re about aligning on what matters most. If you set OKRs then ignore them for quarterly planning, you’re wasting time.

Before Adopting Any Pattern:

  1. What problem does this solve?
  2. Do we have that problem?
  3. What’s the smallest version we can try?
  4. How will we know if it’s working?
  5. What will we stop doing to make room for this?

Combining Patterns

These patterns work best together:

graph TD A[Project Kickoff] --> B[Assign DRI] B --> C[Create Decision Records] C --> D[Daily 5-Min Standups] D --> E{Blocker?} E -->|Yes| F[Office Hours] E -->|No| G[Continue Work] H[Incident?] --> I[Blameless Review] I --> J[Update Decision Records] K[Quarterly Cycle] --> L[Fix-It Week] L --> M[Reduce Technical Debt]

Example:

A team ships a new payment system:

  1. DRI assigned (Alice owns it)
  2. Decision records (Why Stripe over Braintree?)
  3. Spike time-boxes (3 days to evaluate fraud detection)
  4. 5-minute standups (Quick status only)
  5. Office hours (Security expert available Tuesday 2-4 PM)
  6. Incident review (When test transactions fail in production)
  7. Fix-it week (Polish the admin dashboard)

The Meta-Pattern: Inspect and Adapt

The most important pattern is inspecting whether your patterns work.

Every month, ask:

  • What’s working? (Do more of it)
  • What’s annoying? (Fix or eliminate it)
  • What’s missing? (Try something new)

Management patterns aren’t rules. They’re tools. Use the ones that fit. Modify the ones that almost fit. Ignore the ones that don’t.

Your job is to help your team ship great work. Everything else is negotiable.