PagerDuty-Port AI Incident Lifecycle Automation in n8n

PagerDuty webhook events → Port software catalog context → OpenAI severity assessment → Slack tiered alerts & Jira tickets → post-resolution MTTR calculation & post-mortem automation

Who

SREs or platform engineers with PagerDuty, Port, Jira, and Slack accounts, using a self-hosted n8n instance

You get

On incident trigger: auto-fetch service context, assess severity, create tickets, and notify teams. On resolution: auto-calculate MTTR, generate post-mortem template, schedule review meetings, and write reliability metrics back to Port

You need

n8n · slack · jira · port

Steps

1. Configure PagerDuty Webhook and Event Routing

   Create a Webhook node in n8n with path pagerduty/incident and method POST. Configure PagerDuty to send webhooks to this URL. Add a Switch node to route by body.event.event_type: incident.triggered to the trigger flow, incident.resolved to the resolution flow.

2. Query Port Software Catalog for Incident Context

   Add the Port custom node (agentIdentifier: context_retriever_agent), passing incident ID, title, service name, urgency, and created_at. The node queries Port for: service tier, SLA, owners, on-call engineers, deployments in last 48h, dependencies, runbook URLs, monitoring dashboards, and past incidents. Outputs a specified JSON with empty strings/arrays for missing fields.

   Execution prompt · Source text。Port custom node 'Extract Context (New Incident)' prompt field

   Copy prompt

   =A PagerDuty incident has been triggered.
   
   Incident Details:
   - ID: {{ $('On PagerDuty Incident').item.json.body.event.data.id }}
   - Title: {{ $('On PagerDuty Incident').item.json.body.event.data.title }}
   - Service: {{ $('On PagerDuty Incident').item.json.body.event.data.service.name }}
   - Urgency: {{ $('On PagerDuty Incident').item.json.body.event.data.urgency }}
   - Created At: {{ $('On PagerDuty Incident').item.json.body.event.data.created_at }}
   
   Query the Port catalog for comprehensive context about this incident.
   
   Retrieve:
   1. Affected service details (tier, criticality, SLA)
   2. Service owners and current on-call engineers
   3. Recent deployments (last 48 hours)
   4. Related pull requests or configuration changes
   5. Dependencies and upstream/downstream services
   6. Known vulnerabilities or ongoing issues
   7. Runbook URLs and monitoring dashboards
   8. Past similar incidents and resolution patterns
   9. Team's Slack channel
   
   Output as JSON:
   {
     "service_name": "",
     "service_tier": "tier1|tier2|tier3",
     "sla_minutes": 0,
     "owners": [],
     "on_call_engineers": [],
     "slack_channel": "",
     "recent_deployments": [],
     "recent_changes": [],
     "dependencies": [],
     "runbook_url": "",
     "dashboard_url": "",
     "past_incidents_summary": "",
     "known_issues": [],
     "jira_project_key": ""
   }
   
   Rules:
   - Only include data that exists in Port
   - Use empty strings/arrays if not found

3. OpenAI Severity Assessment and Escalation Recommendation

   Add an OpenAI node (model: gpt-4o-mini), feeding Port context along with incident title, service name, and urgency. Returns JSON: severity level (critical/high/medium/low), escalation flag, reason, likely cause, recommended actions, and investigation checklist.

   Execution prompt · Source text。OpenAI node 'Assess Severity' chat messages[0].content field

   Copy prompt

   =You are an incident management expert. Assess this incident and determine if immediate escalation is needed.
   
   Incident:
   - Title: {{ $('On PagerDuty Incident').item.json.body.event.data.title }}
   - Service: {{ $('On PagerDuty Incident').item.json.body.event.data.service.name }}
   - Urgency: {{ $('On PagerDuty Incident').item.json.body.event.data.urgency }}
   
   Context from Port:
   {{ $json.result.message }}
   
   Consider:
   1. Is this a production service?
   2. Were there recent deployments that could be related?
   3. Are there known issues affecting this service?
   4. What is the SLA requirement?
   
   Provide your response as JSON:
   {
     "severity_assessment": "critical|high|medium|low",
     "needs_escalation": true or false,
     "escalation_reason": "reason if needs_escalation is true",
     "likely_cause": "brief assessment of likely cause",
     "recommended_actions": ["action 1", "action 2", "action 3"],
     "investigation_checklist": ["check 1", "check 2", "check 3"]
   }
   
   Return ONLY the JSON object.

4. Slack Tiered Notifications to Team and Leadership

   Add an If node checking needs_escalation. In all cases, send incident details, severity, on-call, likely cause, recommended actions, recent changes, and resource links to the team's Slack channel. If escalation is needed, also send an escalation notice to #leadership-alerts. Channel name read from Port context, defaulting to #incidents if missing.

   Execution prompt · Source text。Slack node 'Notify Team Channel' text field

   Copy prompt

   =:rotating_light: *INCIDENT ALERT*
   
   *{{ $('On PagerDuty Incident').item.json.body.event.data.title }}*
   
   *Service:* {{ $('Parse Context (New Incident)').item.json.result.message.parseJson().service_name }} ({{ $('Parse Context (New Incident)').item.json.result.message.parseJson().service_tier }})
   *Urgency:* {{ $('On PagerDuty Incident').item.json.body.event.data.urgency }}
   *Severity Assessment:* {{ $('Assess Severity').item.json.message.content.parseJson().severity_assessment }}
   
   *On-Call:* {{ $('Parse Context (New Incident)').item.json.result.message.parseJson().on_call_engineers.join(', ') || 'Check PagerDuty' }}
   
   *Likely Cause:*
   {{ $('Assess Severity').item.json.message.content.parseJson().likely_cause }}
   
   *Recommended Actions:*
   {{ $('Assess Severity').item.json.message.content.parseJson().recommended_actions.map((a, i) => (i+1) + '. ' + a).join('\n') }}
   
   *Recent Changes:*
   {{ $('Parse Context (New Incident)').item.json.result.message.parseJson().recent_deployments.slice(0,3).map(d => '- ' + d).join('\n') || 'None in last 48h' }}
   
   *Resources:*
   {{ $('Parse Context (New Incident)').item.json.result.message.parseJson().runbook_url ? '<' + $('Parse Context (New Incident)').item.json.result.message.parseJson().runbook_url + '|Runbook>' : '' }} {{ $('Parse Context (New Incident)').item.json.result.message.parseJson().dashboard_url ? '| <' + $('Parse Context (New Incident)').item.json.result.message.parseJson().dashboard_url + '|Dashboard>' : '' }}
   
   :pagerduty: <{{ $('On PagerDuty Incident').item.json.body.event.data.html_url }}|View in PagerDuty>

   Execution prompt · Source text。Slack node 'Escalate to Leadership' text field

   Copy prompt

   =:rotating_light::rotating_light: *INCIDENT ESCALATION*
   
   *{{ $('On PagerDuty Incident').item.json.body.event.data.title }}*
   
   *Service:* {{ $('Parse Context (New Incident)').item.json.result.message.parseJson().service_name }} ({{ $('Parse Context (New Incident)').item.json.result.message.parseJson().service_tier }})
   *Escalation Reason:* {{ $('Assess Severity').item.json.message.content.parseJson().escalation_reason }}
   
   *Team Channel:* {{ $('Parse Context (New Incident)').item.json.result.message.parseJson().slack_channel || '#incidents' }}
   *On-Call:* {{ $('Parse Context (New Incident)').item.json.result.message.parseJson().on_call_engineers.join(', ') || 'Check PagerDuty' }}
   
   :pagerduty: <{{ $('On PagerDuty Incident').item.json.body.event.data.html_url }}|View in PagerDuty>
   
   _Response team has been notified._

5. Create Jira Incident Ticket and Notify

   Add a Jira node. Project key read from Port context (default INC). Issue type Bug. Priority mapped from severity (critical→Highest, high→High, others→Medium). Description includes full incident details, service context, AI assessment, investigation checklist, recommended actions, recent changes, resource links, and past incident summary. After creation, send confirmation to the team channel.

   Execution prompt · Source text。Slack node 'Notify Jira Created' text field

   Copy prompt

   =:jira: *Incident Ticket Created*
   
   {{ $json.key }}
   
   Track investigation and resolution in Jira.

6. Post-Resolution Context Extraction and Post-Mortem Template Generation

   On incident resolution, the Port node (agentIdentifier: context_retriever_agent) queries service details, owners, Slack channel, changes during incident window, Confluence/Notion space, and calendar integration, calculating incident_duration_minutes. Then an OpenAI node (gpt-4o-mini) generates a structured post-mortem JSON template with timeline, impact, root cause analysis placeholder, action items, and lessons learned.

   Execution prompt · Source text。Port node 'Extract Context (Resolved)' prompt field

   Copy prompt

   =A PagerDuty incident has been resolved.
   
   Incident Details:
   - ID: {{ $('On PagerDuty Incident').item.json.body.event.data.id }}
   - Title: {{ $('On PagerDuty Incident').item.json.body.event.data.title }}
   - Service: {{ $('On PagerDuty Incident').item.json.body.event.data.service.name }}
   - Created At: {{ $('On PagerDuty Incident').item.json.body.event.data.created_at }}
   - Resolved At: {{ $('On PagerDuty Incident').item.json.body.event.data.resolved_at || new Date().toISOString() }}
   
   Query the Port catalog for post-incident context.
   
   Retrieve:
   1. Service details and owners
   2. Team's Slack channel
   3. Changes made during the incident window
   4. Confluence/Notion space for post-mortems
   5. Calendar integration details for scheduling
   
   Calculate incident_duration_minutes from created_at to resolved_at.
   
   Output as JSON:
   {
     "service_name": "",
     "owners": [],
     "slack_channel": "",
     "confluence_space": "",
     "calendar_id": "",
     "incident_duration_minutes": 0,
     "changes_during_incident": [],
     "stakeholders_to_invite": []
   }
   
   Only include data that exists in Port.

   Execution prompt · Source text。OpenAI node 'Generate Post-Mortem Template' chat messages[0].content field

   Copy prompt

   =Create a post-mortem document template for this resolved incident.
   
   Incident:
   - ID: {{ $('On PagerDuty Incident').item.json.body.event.data.id }}
   - Title: {{ $('On PagerDuty Incident').item.json.body.event.data.title }}
   - Service: {{ $json.result.message.parseJson().service_name }}
   - Duration: {{ $json.result.message.parseJson().incident_duration_minutes }} minutes
   - Created: {{ $('On PagerDuty Incident').item.json.body.event.data.created_at }}
   - Resolved: {{ $('On PagerDuty Incident').item.json.body.event.data.resolved_at }}
   
   Context:
   {{ $json.result.message }}
   
   Create a structured post-mortem template as JSON:
   {
     "title": "Post-Mortem: [incident title]",
     "summary": "Brief 2-3 sentence summary",
     "timeline": [
       {"time": "HH:MM", "event": "Incident detected"},
       {"time": "HH:MM", "event": "Response initiated"},
       {"time": "HH:MM", "event": "Root cause identified"},
       {"time": "HH:MM", "event": "Resolution applied"},
       {"time": "HH:MM", "event": "Incident resolved"}
     ],
     "impact": "Description of customer/business impact",
     "root_cause_analysis": "[To be filled during post-mortem meeting]",
     "action_items": [
       {"action": "Suggested action 1", "owner": "TBD", "due_date": "TBD"},
       {"action": "Suggested action 2", "owner": "TBD", "due_date": "TBD"}
     ],
     "lessons_learned": "[To be filled during post-mortem meeting]",
     "meeting_attendees": []
   }
   
   Return ONLY the JSON object.

7. Port AI Agent Schedules Post-Mortem and Notifies Team

   Add a Port node (agentIdentifier: post_mortem_scheduler_agent), passing incident details, duration, resolved time, stakeholder list, and post-mortem template content. Agent tasks: create post-mortem document, schedule meeting 2-3 business days out, invite relevant stakeholders, include document link in invite. Returns JSON with document status, meeting time, and attendees. After parsing, send resolution notice to team channel with MTTR, document link, and meeting details.

   Execution prompt · Source text。Port node 'Schedule Post-Mortem via Port' prompt field

   Copy prompt

   =An incident has been resolved and needs a post-mortem meeting scheduled.
   
   Incident Details:
   - ID: {{ $('On PagerDuty Incident').item.json.body.event.data.id }}
   - Title: {{ $('On PagerDuty Incident').item.json.body.event.data.title }}
   - Service: {{ $('Parse Context (Resolved)').item.json.result.message.parseJson().service_name }}
   - Duration: {{ $('Parse Context (Resolved)').item.json.result.message.parseJson().incident_duration_minutes }} minutes
   - Resolved At: {{ $('On PagerDuty Incident').item.json.body.event.data.resolved_at }}
   
   Stakeholders to invite:
   {{ $('Parse Context (Resolved)').item.json.result.message.parseJson().stakeholders_to_invite.join(', ') || $('Parse Context (Resolved)').item.json.result.message.parseJson().owners.join(', ') }}
   
   Post-Mortem Template:
   {{ $('Generate Post-Mortem Template').item.json.message.content }}
   
   Your tasks:
   1. Create a post-mortem document (in Confluence/Notion if available) with the template content
   2. Schedule a post-mortem meeting for 2-3 business days from now
   3. Invite relevant stakeholders (service owners, on-call engineers who responded)
   4. Include the incident details and post-mortem document link in the meeting invite
   
   Respond with JSON:
   {
     "document_created": true or false,
     "document_url": "URL if created",
     "meeting_scheduled": true or false,
     "meeting_time": "ISO timestamp",
     "attendees_invited": [],
     "status": "success|partial|failed",
     "message": "Summary of actions taken"
   }

   Execution prompt · Source text。Slack node 'Notify Incident Resolved' text field

   Copy prompt

   =:white_check_mark: *INCIDENT RESOLVED*
   
   *{{ $('On PagerDuty Incident').item.json.body.event.data.title }}*
   
   *Service:* {{ $('Parse Context (Resolved)').item.json.result.message.parseJson().service_name }}
   *Duration:* {{ $('Parse Context (Resolved)').item.json.result.message.parseJson().incident_duration_minutes }} minutes
   *MTTR:* {{ Math.floor($('Parse Context (Resolved)').item.json.result.message.parseJson().incident_duration_minutes / 60) }}h {{ $('Parse Context (Resolved)').item.json.result.message.parseJson().incident_duration_minutes % 60 }}m
   
   *Post-Mortem:*
   {{ $json.result.message.parseJson().document_url ? '<' + $json.result.message.parseJson().document_url + '|View Document>' : 'Document creation pending' }}
   
   *Post-Mortem Meeting:*
   {{ $json.result.message.parseJson().meeting_scheduled ? 'Scheduled for ' + $json.result.message.parseJson().meeting_time : 'Scheduling in progress' }}
   {{ $json.result.message.parseJson().attendees_invited.length > 0 ? 'Attendees: ' + $json.result.message.parseJson().attendees_invited.join(', ') : '' }}
   
   {{ $json.result.message.parseJson().message }}
   
   :pagerduty: <{{ $('On PagerDuty Incident').item.json.body.event.data.html_url }}|View in PagerDuty>

8. Write MTTR Metrics Back to Port

   Add a Port node (agentIdentifier: metrics_logger_agent), passing incident ID, service name, MTTR in minutes, and resolved time. Tasks: update the service entity in Port with latest MTTR, increment incident count, update last incident timestamp. Returns JSON confirming whether metrics were logged.

   Execution prompt · Source text。Port node 'Log MTTR to Port' prompt field

   Copy prompt

   =Log the incident resolution metrics to Port.
   
   Incident:
   - ID: {{ $('On PagerDuty Incident').item.json.body.event.data.id }}
   - Service: {{ $('Parse Context (Resolved)').item.json.result.message.parseJson().service_name }}
   - MTTR: {{ $('Parse Context (Resolved)').item.json.result.message.parseJson().incident_duration_minutes }} minutes
   - Resolved At: {{ $('On PagerDuty Incident').item.json.body.event.data.resolved_at }}
   
   Update the service entity in Port with:
   1. Latest incident MTTR
   2. Increment incident count
   3. Update last incident timestamp
   
   Respond with JSON:
   {
     "metrics_logged": true or false,
     "service_updated": "",
     "message": ""
   }

You are setting up an n8n workflow for automated incident lifecycle management. Please confirm the following prerequisites first:
1. You are using a self-hosted n8n instance (the template explicitly states Self-Hosted only).
2. You have registered on Port.io and configured your software catalog, on-call schedules, and deployment history.
3. You have installed the Port custom node in n8n and configured credentials for portIoApi, openAiApi, slackApi, and jiraSoftwareCloudApi.
4. Your PagerDuty webhook can reach your n8n instance's public URL.
5. Slack channels #incidents and #leadership-alerts exist; Jira project key is INC (or customize as needed).

After confirmation, import the workflow.json or build manually per node descriptions. Key checks:
- Webhook path matches PagerDuty configuration;
- Switch node rules match incident.triggered / incident.resolved;
- Port node agentIdentifier matches your AI Agent names in Port;
- OpenAI node model selection matches your account (template uses gpt-4o-mini).

Before first production run, test with a PagerDuty test event to verify the trigger flow (Slack message received, Jira ticket created), then test the resolution flow.