OperatorRadar
DiscoverAI ToolsAI AgentsDecision GuidesPromptsWorkflowsInsightsCategoriesSubmitAbout
Submit a ToolFind My Solution
OperatorRadar

Find the tools, systems, and ideas that move your business forward. Timeless business thinking, rebuilt for the AI era.

Discover

  • Discover
  • AI Tools
  • AI Agents
  • Software
  • Agencies
  • Categories

Decide

  • Decision Guides
  • Compare
  • Find My Solution
  • Insights

Execute

  • Prompts
  • Workflows
  • Submit a Tool
  • Contact

Company

  • About
  • Privacy
  • Terms

© 2026 OperatorRadar. All rights reserved.

Built by Ekofi

  1. Home
  2. Prompts
  3. Blameless Postmortem Facilitator
Featured
intermediate
Claude or ChatGPT (verify current model choice)
v1.0.0

Blameless Postmortem Facilitator

Transform incident timeline notes into a structured blameless postmortem that surfaces systemic causes and actionable improvements without assigning fault.

Full prompt

You are a skilled incident postmortem facilitator. Your role is to help engineering teams conduct blameless postmortems that build psychological safety and drive systemic improvement.

Incident Details:
- Service/System: {{service_name}}
- Duration: {{incident_duration}}
- Severity: {{severity_level}}
- Date: {{incident_date}}

Timeline Notes:
{{timeline_notes}}

Participants: {{participant_roles}}

Your task:
1. Reconstruct a clear, chronological timeline from the notes provided. Identify decision points and information gaps.
2. Categorize contributing factors as: technical (code, infrastructure, monitoring), process (runbooks, escalation, communication), or environmental (load, dependencies, external services).
3. For each factor, ask "Why?" up to three times to surface systemic causes, not individual errors.
4. Identify what worked well—these are practices to reinforce.
5. Generate 3–5 specific, testable action items. Each should have: clear owner, deadline, and success metric.
6. Suggest one process or tool change that would have prevented or shortened this incident.

Format the output as a postmortem document suitable for sharing with the team and leadership. Use neutral, learning-focused language. Avoid phrases like "human error" or "operator mistake." Instead, describe conditions and decisions that led to the incident.

Postmortem Structure:
- Executive Summary (2–3 sentences)
- Timeline (with decision points)
- Contributing Factors (by category)
- Root Cause Analysis (systems-level)
- What Went Well
- Action Items (with owners and deadlines)
- Process Improvement Recommendation

How to use

1. Gather incident timeline notes from your incident channel, war room transcript, or monitoring alerts. Include timestamps and key decisions. 2. Fill in the service name, duration, severity, and date. 3. Paste your timeline notes into the prompt. 4. Optionally, list participant roles to add context. 5. Run the prompt and review the output with your team. 6. Use the structured postmortem as the basis for your synchronous postmortem meeting or async review. 7. Assign owners to action items and track completion in your incident management tool.

Example input

Service: User Authentication Service | Duration: 1 hour 20 minutes | Severity: SEV-1 | Date: 2024-01-10

Timeline Notes:
14:32 - Alerts fire: Auth service latency >5s
14:35 - On-call engineer pages database team
14:38 - Database team confirms CPU at 95%, connection pool exhausted
14:40 - Incident commander opens war room
14:42 - Team decides to scale database replicas
14:50 - Scaling in progress, latency still high
14:55 - Engineer discovers new query in recent deploy (merged 2 hours ago) doing full table scan
15:00 - Query rolled back
15:05 - Latency returns to normal
15:10 - All clear

Participants: On-call engineer, Database team lead, Incident commander, Backend engineer who deployed

Example output

# Postmortem: User Authentication Service Outage
## 2024-01-10 | 14:32–15:10 UTC

**Executive Summary**
The User Authentication Service experienced 38 minutes of elevated latency (>5s) due to a newly deployed query that performed full table scans on a high-cardinality table. The incident was resolved by rolling back the deploy. No user data was lost, but login latency affected ~15% of requests during the window.

**Timeline**
- 14:32 UTC: Latency alerts trigger (>5s p99)
- 14:35 UTC: On-call engineer pages database team
- 14:38 UTC: Database team identifies CPU saturation (95%) and connection pool exhaustion
- 14:40 UTC: Incident commander opens war room; team considers scaling
- 14:42 UTC: Decision made to scale database replicas (estimated 10–15 min)
- 14:55 UTC: During scaling, engineer reviews recent deploys; identifies new query in auth service (merged 2 hours prior)
- 14:58 UTC: Query analysis confirms full table scan on users table (2M rows)
- 15:00 UTC: Rollback initiated
- 15:05 UTC: Latency normalizes; all-clear declared

**Contributing Factors**

*Technical*
- New query in authentication service performed full table scan instead of indexed lookup
- No query performance testing in staging environment
- Monitoring did not alert on query execution time (only latency)

*Process*
- Code review did not catch N+1 or full table scan patterns
- No runbook for "latency spike → check recent deploys"
- Scaling decision made before root cause investigation (added 10 min to resolution)

*Environmental*
- Database connection pool sized for baseline load; no headroom for spikes

**Root Cause Analysis**
- Why did latency spike? A new query performed a full table scan.
- Why was the query deployed? Code review did not catch the performance issue.
- Why didn't code review catch it? No automated query analysis tool; reviewer relied on manual inspection.
- Why did resolution take 38 minutes? Team pursued scaling before investigating recent changes; root cause discovery was reactive, not proactive.

**What Went Well**
- Alert fired within 3 minutes of incident start
- Incident commander opened war room immediately
- Team communicated clearly in real time
- Rollback process was smooth and fast (2 min)

**Action Items**
1. **Add query performance testing to CI/CD pipeline** | Owner: Backend team lead | Deadline: 2024-01-24 | Success metric: All queries with >10ms execution time flagged in PR
2. **Create "latency spike" runbook with decision tree** | Owner: Incident commander | Deadline: 2024-01-17 | Success metric: Runbook used in next incident; resolution time <20 min
3. **Increase database connection pool headroom by 30%** | Owner: Database team lead | Deadline: 2024-01-22 | Success metric: Pool utilization stays <70% under peak load
4. **Add query execution time to monitoring dashboard** | Owner: Observability engineer | Deadline: 2024-01-19 | Success metric: Slow query alerts fire before latency alerts

**Process Improvement Recommendation**
Implement automated query analysis in code review (e.g., via a tool like sqlc or pganalyze integration). This would have caught the full table scan before merge and prevented the incident entirely.

Customization tips

  • Adjust the number of "Why" iterations (currently 3) based on your team's depth preference. Fewer iterations for faster postmortems; more for complex systemic issues.
  • If your team uses a specific postmortem template (e.g., Google's or Etsy's), modify the output format section to match your internal standard.
  • Add a 'Severity Justification' section if your organization requires explicit reasoning for severity assignment.
  • Include a 'Customer Impact' section if you need to quantify affected users, revenue, or SLAs for stakeholder communication.
  • For high-frequency incidents, add a 'Trend Analysis' prompt to identify patterns across multiple postmortems.
  • Customize the action item format to match your tracking tool (Jira, Linear, etc.) if you plan to export directly.