Skip to main content

Check out Port for yourself ➜ 

Orchestrate incident response with AI

When incidents occur, engineers waste critical minutes manually coordinating response logistics instead of fixing the actual problem. They need to create dedicated Slack channels, set up Zoom meetings for war rooms, create tracking tickets in Jira, and notify the right people, all while gathering context about affected services.

This guide demonstrates how to implement an AI-powered incident response system in Port. When an incident is created, orchestration can run in one of two ways:

  1. Workflow: A single workflow runs a fixed sequence of steps (Slack channel, Zoom meeting, Jira ticket, notifications) based on severity.

  2. Actions & Automations: An AI agent has access to Port actions and automatically chooses and runs the right sequence based on the incident context.

Both approaches use the same data model, external tools, and secrets. Only the implementation (workflow vs. actions + automations + AI agent) differs.

Incident orchestration workflow

Common use cases​

  • Eliminate manual coordination delays by automating incident setup tasks
  • Ensure consistent incident response with standardized communication channels and tracking
  • Scale incident management across teams without requiring every engineer to know all setup steps
  • Accelerate time to resolution by removing logistics overhead during high-stress situations

Prerequisites​

This guide assumes the following:

  • You have a Port account and have completed the onboarding process
  • You have access to one of Port's incident management integrations (we'll use PagerDuty in this guide)
  • You have access to a Slack developer account with permissions to create apps
  • You have access to a Zoom developer account with permissions to create Server-to-Server OAuth apps
  • You have access to a Jira instance with API access
  • For the Actions & Automations option: you have access to create and configure AI agents in Port.
  • For the Workflow option: you have access to workflows in Port. Note that Port's workflow is currently in closed beta. Workflows may undergo breaking changes and occasional downtime without prior notice.
Alternative integrations

While this guide uses PagerDuty for incident management, you can adapt it for other incident management tools like FireHydrant, Incident.io, or Opsgenie. The same principles apply regardless of the incident source.

Set up data model​

We will configure the necessary blueprint to support our AI-powered incident orchestration workflow.

Create PagerDuty incident blueprint​

The incident blueprint will store incident data from your incident management tool and track orchestration results.

  1. Go to the builder page of your portal.

  2. Click on + Blueprint.

  3. Click on the {...} Edit JSON button.

  4. Copy and paste the following JSON configuration:

    PagerDuty incident blueprint (click to expand)
    {
      "identifier": "pagerdutyIncident",
      "description": "This blueprint represents a PagerDuty incident in our software catalog",
      "title": "PagerDuty Incident",
      "icon": "pagerduty",
      "schema": {
      "properties": {
        "status": {
          "icon": "DefaultProperty",
          "title": "Incident Status",
          "type": "string",
          "enum": [
            "triggered",
            "annotated",
            "acknowledged",
            "reassigned",
            "escalated",
            "reopened",
            "resolved",
            "escalated to human"
          ],
          "enumColors": {
            "triggered": "red",
            "annotated": "blue",
            "acknowledged": "yellow",
            "reassigned": "blue",
            "escalated": "yellow",
            "reopened": "red",
            "resolved": "green",
            "escalated to human": "bronze"
          }
        },
        "url": {
          "type": "string",
          "format": "url",
          "title": "Incident URL"
        },
        "urgency": {
          "title": "Incident Urgency",
          "type": "string",
          "enum": [
            "high",
            "low"
          ],
          "enumColors": {
            "high": "red",
            "low": "green"
          }
        },
        "priority": {
          "title": "Priority",
          "type": "string"
        },
        "severity": {
          "type": "string",
          "title": "Severity",
          "enum": [
            "Critical",
            "High",
            "Medium",
            "Low"
          ],
          "enumColors": {
            "Critical": "red",
            "High": "red",
            "Medium": "yellow",
            "Low": "lime"
          }
        },
        "description": {
          "type": "string",
          "title": "Description"
        },
        "assignees": {
          "title": "Assignees",
          "type": "array",
          "items": {
            "type": "string",
            "format": "user"
          }
        },
        "escalation_policy": {
          "type": "string",
          "title": "Escalation Policy"
        },
        "created_at": {
          "title": "Created At",
          "type": "string",
          "format": "date-time"
        },
        "updated_at": {
          "title": "Updated At",
          "type": "string",
          "format": "date-time"
        },
        "resolved_at": {
          "title": "Incident Resolution Time",
          "type": "string",
          "format": "date-time",
          "description": "The timestamp when the incident was resolved"
        },
        "recovery_time": {
          "title": "Time to Recovery",
          "type": "number",
          "description": "The time (in minutes) between the incident being triggered and resolved"
        },
        "triggered_by": {
          "type": "string",
          "title": "Triggered By"
        },
        "slack_channel": {
          "type": "string",
          "title": "Slack Channel",
          "description": "The Slack channel created for this incident",
          "icon": "Slack"
        },
        "zoom_meeting_link": {
          "type": "string",
          "title": "Zoom Meeting Link",
          "description": "The Zoom meeting link for the war room",
          "icon": "Team",
          "format": "url"
        },
        "jira_tracking_ticket": {
          "type": "string",
          "title": "Jira Tracking Ticket",
          "icon": "Jira",
          "format": "url",
          "description": "The Jira ticket created to track this incident"
        }
      },
        "required": []
      },
      "mirrorProperties": {},
      "calculationProperties": {},
      "relations": {
        "pagerdutyService": {
          "title": "PagerDuty Service",
          "target": "pagerdutyService",
          "required": false,
          "many": false
        }
      }
    }

  5. Click Create to save the blueprint.

If you already have PagerDuty integration installed

Port's PagerDuty integration creates a pagerdutyIncident blueprint by default. You can extend this existing blueprint by adding the following properties to enable orchestration tracking:

  1. Go to the builder page of your portal.

  2. Select the PagerDuty Incident blueprint.

  3. Click on the {...} Edit JSON button.

  4. Add the following properties under the properties schema:

    PagerDuty incident blueprint extended properties (click to expand)
    "slack_channel": {
      "type": "string",
      "title": "Slack Channel",
      "description": "The Slack channel created for this incident"
    },
    "zoom_meeting_link": {
      "type": "string",
      "format": "url",
      "title": "Zoom Meeting Link",
      "description": "The Zoom meeting link for the war room"
    },
    "jira_tracking_ticket": {
      "type": "string",
      "format": "url",
      "title": "Jira Tracking Ticket",
      "description": "The Jira ticket created to track this incident"
    }

The rest of this guide will reference pagerdutyIncident as the blueprint identifier.

Set up external tools​

We need to configure integrations with Slack, Zoom, and Jira to enable the orchestration actions.

Set up Slack App​

  1. Create a Slack app and install it on a workspace.

  2. Add the following permissions to the Slack app:

    • Create channel (Required):

      • channels:manage
      • groups:write
      • im:write
      • mpim:write

    • Find a user with an email address (Optional):

      • users:read.email

    • Invite users to channel (Optional):

      • channels:write.invites
      • groups:write.invites
      • mpim:write.invites

    • Send messages (Required):

      • chat:write
      • chat:write.public
    User permissions

    Without scopes for Find a user with an email address and Invite users to channel, the channel will be created but users will not be added to it automatically.

  3. Install the app in your Slack workspace.

  4. Navigate back to the OAuth & Permissions page. You will see an access token under OAuth Tokens for Your Workspace that you will use in the SLACK_BOT_TOKEN Port secret.

Set up Zoom Meeting​

Create a Server-to-Server OAuth app:

  1. Go to Zoom Marketplace.

  2. Click Develop → Build App → select Server-to-Server OAuth.

  3. Fill in the app details and make note of:

    • Account ID
    • Client ID
    • Client Secret

  4. Under Scopes, add:

    • meeting:write
    • meeting:read
    • (optionally) user:read

Set up Jira API access​

  1. Log in to your Jira instance.

  2. Generate an API token:

Add Port secrets​

To add secrets to your portal:

  1. Click on the ... button in the top right corner of your Port application.

  2. Click on Credentials.

  3. Click on the Secrets tab.

  4. Click on + Secret and add the following secrets:

    • SLACK_BOT_TOKEN - Your Slack bot token from the OAuth & Permissions page
    • ZOOM_ACCOUNT_ID - Your Zoom account ID
    • ZOOM_CLIENT_ID - Your Zoom client ID
    • ZOOM_CLIENT_SECRET - Your Zoom client secret
    • JIRA_AUTH - Base64 encoded string of your Jira credentials. Generate this by running: 
      echo -n "your-email@domain.com:your-api-token" | base64
      Replace your-email@domain.com with your Jira email and your-api-token with your Jira API token.

Orchestration implementation in Port​

Choose one implementation. The data model and external tools above are the same for both.

  • Workflow: One workflow defines the full sequence. When an incident is created, the workflow runs and branches by severity (critical/high, medium, low). No AI agent, the flow is deterministic and visible in the workflow editor.
  • Actions & Automations: You create separate actions (Slack, Zoom, Jira, notify) and automations that trigger an AI agent and update the incident when actions complete. The AI agent decides which actions to run based on incident context.

Build the workflow

Use Port's workflow feature to chain nodes (Slack, Zoom, Jira, notifications, entity update) in a single workflow. The workflow runs automatically when a PagerDuty incident is created.

We will build the workflow using the workflow editor and the AI assistant to generate the initial structure. You can also skip the AI assistant and paste the workflow template directly.

  1. Go to the workflows page of your portal.

  2. Click + Workflow button in the top-right corner.

  3. Click on Skip to editor to open the workflow editor.

  4. Copy and paste this JSON template directly into the workflow editor.

    Incident orchestration workflow template (click to expand)
    {
      "identifier": "incident_orchestration_workflow",
      "title": "Automated Incident Orchestration",
      "icon": "Alert",
      "description": "Automatically orchestrates incident response by creating Slack channels, Zoom meetings, Jira tickets, and notifications based on incident severity. Updates the incident entity with all created resources in a single bulk update.",
      "allowAnyoneToViewRuns": true,
      "nodes": [
        {
          "identifier": "create_jira_ticket_critical",
          "title": "Create Jira Tracking Ticket",
          "icon": "Jira",
          "description": "Creates Jira bug ticket for critical/high incidents",
          "config": {
            "type": "WEBHOOK",
            "url": "<YOUR_JIRA_ORGANIZATION_URL>/rest/api/3/issue",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Content-Type": "application/json",
              "Authorization": "Basic {{ .secrets.JIRA_AUTH }}"
            },
            "body": {
              "fields": {
                "labels": [
                  "port-workflow",
                  "incident"
                ],
                "project": {
                  "key": "<YOUR_JIRA_PROJECT>"
                },
                "summary": "{{.outputs.trigger.incident_title}}",
                "issuetype": {
                  "name": "Bug"
                },
                "description": {
                  "type": "doc",
                  "content": [
                    {
                      "type": "paragraph",
                      "content": [
                        {
                          "text": "Incident Details\n\n- Priority: {{ .outputs.trigger.incident_priority }}\n- Urgency: {{ .outputs.trigger.incident_urgency }}\n- Status: {{ .outputs.trigger.incident_status }}\n- PagerDuty URL: {{ .outputs.trigger.incident_url }}\n\nDescription:\n{{ .outputs.trigger.incident_description }}\n\nResponse Resources:\n- Slack Channel: {{ .outputs.create_slack_channel_critical.slack_channel_name }}\n- Zoom Meeting: {{.outputs.create_zoom_meeting_critical.zoom_meeting_url }}",
                          "type": "text"
                        }
                      ]
                    }
                  ],
                  "version": 1
                }
              }
            }
          },
          "variables": {
            "jira_ticket_url": "https://{{ (.response.data.self | capture(\"https://(?<domain>[^/]+)\") ).domain }}/browse/{{ .response.data.key }}"
          }
        },
        {
          "identifier": "create_jira_ticket_medium",
          "title": "Create Jira Tracking Ticket",
          "icon": "Jira",
          "description": "Creates Jira bug ticket for medium priority incidents",
          "config": {
            "type": "WEBHOOK",
            "url": "<YOUR_JIRA_ORGANIZATION_URL>/rest/api/3/issue",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Content-Type": "application/json",
              "Authorization": "Basic {{ .secrets.JIRA_AUTH }}"
            },
            "body": {
              "fields": {
                "labels": [
                  "port-workflow",
                  "incident"
                ],
                "project": {
                  "key": "<YOUR_JIRA_PROJECT>"
                },
                "summary": "{{.outputs.trigger.incident_title}}",
                "issuetype": {
                  "name": "Bug"
                },
                "description": {
                  "type": "doc",
                  "content": [
                    {
                      "type": "paragraph",
                      "content": [
                        {
                          "text": "Incident Details\n\n- Priority: {{ .outputs.trigger.incident_priority }}\n- Urgency: {{ .outputs.trigger.incident_urgency }}\n- Status: {{ .outputs.trigger.incident_status }}\n- PagerDuty URL: {{ .outputs.trigger.incident_url }}\n\nDescription:\n{{ .outputs.trigger.incident_description }}\n\nResponse Resources:\n- Slack Channel: {{ .outputs.create_slack_channel_medium.slack_channel_name }}",
                          "type": "text"
                        }
                      ]
                    }
                  ],
                  "version": 1
                }
              }
            }
          },
          "variables": {
            "jira_ticket_url": "https://{{ (.response.data.self | capture(\"https://(?<domain>[^/]+)\") ).domain }}/browse/{{ .response.data.key }}"
          }
        },
        {
          "identifier": "create_slack_channel_critical",
          "title": "Create Incident Slack Channel (C)",
          "icon": "Slack",
          "description": "Creates dedicated Slack channel for critical/high incidents",
          "config": {
            "type": "WEBHOOK",
            "url": "https://slack.com/api/conversations.create",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Content-Type": "application/json",
              "Authorization": "Bearer {{ .secrets.SLACK_BOT_TOKEN }}"
            },
            "body": {
              "name": "{{ .outputs.trigger.incident_id  | ascii_downcase }}",
              "is_private": false
            }
          },
          "variables": {
            "slack_channel_name": "#{{ .response.data.channel.name }}"
          }
        },
        {
          "identifier": "create_slack_channel_medium",
          "title": "Create Incident Slack Channel (M)",
          "icon": "Slack",
          "description": "Creates dedicated Slack channel for medium priority incidents",
          "config": {
            "type": "WEBHOOK",
            "url": "https://slack.com/api/conversations.create",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Content-Type": "application/json",
              "Authorization": "Bearer {{ .secrets.SLACK_BOT_TOKEN }}"
            },
            "body": {
              "name": "{{ .outputs.trigger.incident_id  | ascii_downcase }}",
              "is_private": false
            }
          },
          "variables": {
            "slack_channel_name": "#{{ .response.data.channel.name }}"
          }
        },
        {
          "identifier": "create_zoom_meeting_critical",
          "title": "Create War Room Meeting",
          "icon": "Team",
          "description": "Set up a Zoom meeting for the war room after obtaining access token",
          "config": {
            "type": "WEBHOOK",
            "url": "https://api.zoom.us/v2/users/me/meetings",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Content-Type": "application/json",
              "Authorization": "Bearer {{ .outputs.get_zoom_meeting_access_token.zoom_access_token }}"
            },
            "body": {
              "type": 2,
              "topic": "{{ .outputs.trigger.incident_title }}",
              "duration": 60,
              "settings": {
                "mute_upon_entry": true,
                "join_before_host": true
              },
              "timezone": "UTC",
              "start_time": "{{ now | todateiso8601 }}"
            }
          },
          "variables": {
            "zoom_meeting_url": "{{ .response.data.join_url }}"
          }
        },
        {
          "identifier": "determine_severity",
          "title": "Determine Severity Level",
          "icon": null,
          "description": "Evaluates priority and urgency to determine response level",
          "config": {
            "type": "CONDITION",
            "options": [
              {
                "identifier": "critical_high",
                "title": "Critical/High Priority",
                "expression": "(.outputs.trigger.incident_priority == \"P1\" or .outputs.trigger.incident_priority == \"P2\" or .outputs.trigger.incident_urgency == \"Critical\" or .outputs.trigger.incident_urgency == \"High\" or .outputs.trigger.incident_urgency == \"high\")"
              },
              {
                "identifier": "medium",
                "title": "Medium Priority",
                "expression": "(.outputs.trigger.incident_priority == \"P3\" or .outputs.trigger.incident_urgency == \"Medium\" or .outputs.trigger.incident_urgency == \"medium\")"
              },
              {
                "identifier": "low",
                "title": "Low Priority",
                "expression": "(.outputs.trigger.incident_priority == \"P4\" or .outputs.trigger.incident_urgency == \"Low\" or .outputs.trigger.incident_urgency == \"low\")"
              }
            ]
          },
          "variables": {}
        },
        {
          "identifier": "get_zoom_meeting_access_token",
          "title": "Get Zoom Access Token",
          "icon": "Key",
          "description": "Set up a Zoom meeting for the war room by first obtaining access token and then proceeding to call the create zoom meeting link",
          "config": {
            "type": "WEBHOOK",
            "url": "https://zoom.us/oauth/token",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Content-Type": "application/x-www-form-urlencoded",
              "Authorization": "Basic {{ .secrets.ZOOM_CLIENT_ID + \":\" + .secrets.ZOOM_CLIENT_SECRET | @base64 }}"
            },
            "body": {
              "account_id": "{{ .secrets.ZOOM_ACCOUNT_ID }}",
              "grant_type": "account_credentials"
            }
          },
          "variables": {
            "zoom_access_token": "{{ .response.data.access_token }}"
          }
        },
        {
          "identifier": "notify_teams_critical",
          "title": "Notify Teams (Critical/High)",
          "icon": "Slack",
          "description": "Sends comprehensive Slack notification for critical/high incidents",
          "config": {
            "type": "WEBHOOK",
            "url": "https://slack.com/api/chat.postMessage",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Content-Type": "application/json; charset=utf-8",
              "Authorization": "Bearer {{ .secrets.SLACK_BOT_TOKEN }}"
            },
            "body": {
              "blocks": [
                {
                  "text": "🚨 *INCIDENT ALERT* 🚨\n\n*Incident:* {{ .outputs.trigger.incident_title }}\n*Priority:* `{{ .outputs.trigger.incident_priority }}` | *Urgency:* `{{ .outputs.trigger.incident_urgency }}`\n*Status:* {{ .outputs.trigger.incident_status }}\n\n📋 *Response Resources Created:*\n• Slack Channel: {{ .outputs.create_slack_channel_critical.slack_channel_name }} \n• Jira Ticket: <{{ .outputs.create_jira_ticket_critical.jira_ticket_url }}|View ticket in Jira>\n• PagerDuty: <{{ .outputs.trigger.incident_url }}|View incident in PagerDuty>\n• Zoom meeting: <{{ .outputs.create_zoom_meeting_critical.zoom_meeting_url}}|Join Zoom>\n\n <{{.outputs.trigger.incident_url}}|View incident in Port>⚡ *Action Required:* Join the Slack channel and Zoom meeting immediately!",
                  "type": "markdown"
                }
              ],
              "channel": "{{ .outputs.create_slack_channel_critical.slack_channel_name }}"
            }
          },
          "variables": {}
        },
        {
          "identifier": "notify_teams_low",
          "title": "Notify Teams (Low)",
          "icon": "Slack",
          "description": "Sends simple Slack notification for low priority incidents",
          "config": {
            "type": "WEBHOOK",
            "url": "https://slack.com/api/chat.postMessage",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Content-Type": "application/json; charset=utf-8",
              "Authorization": "Bearer {{ .secrets.SLACK_BOT_TOKEN }}"
            },
            "body": {
              "blocks": [
                {
                  "text": "ℹ️ *Low Priority Incident*\n\n*Incident:* {{ .outputs.trigger.incident_title }}\n*Priority:* `{{ .outputs.trigger.incident_priority }}` | *Urgency:* `{{ .outputs.trigger.incident_urgency }}`\n*Status:* {{ .outputs.trigger.incident_status }}\n\n🔗 <{{ .outputs.trigger.incident_url }}|View incident in Port>\n\n📝 No immediate action required. Monitor as needed.",
                  "type": "markdown"
                }
              ],
              "channel": "#isaac-test"
            }
          },
          "variables": {}
        },
        {
          "identifier": "notify_teams_medium",
          "title": "Notify Teams (Medium)",
          "icon": "Slack",
          "description": "Sends Slack notification for medium priority incidents",
          "config": {
            "type": "WEBHOOK",
            "url": "https://slack.com/api/chat.postMessage",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Content-Type": "application/json; charset=utf-8",
              "Authorization": "Bearer {{ .secrets.SLACK_BOT_TOKEN }}"
            },
            "body": {
              "blocks": [
                {
                  "text": "⚠️ *Incident Alert*\n\n*Incident:* {{ .outputs.trigger.incident_title }}\n*Priority:* `{{ .outputs.trigger.incident_priority }}` | *Urgency:* `{{ .outputs.trigger.incident_urgency }}`\n*Status:* {{ .outputs.trigger.incident_status }}\n\n📋 *Response Resources Created:*\n• Slack Channel: {{ .outputs.create_slack_channel_medium.slack_channel_name }} \n• Jira Ticket: <{{ .outputs.create_jira_ticket_medium.jira_ticket_url }}|View in Jira>\n• PagerDuty: <{{ .outputs.trigger.incident_url }}|View in PagerDuty>\n\n:link: <{{.outputs.trigger.incident_url}}|View incident in Port>👀 Please review and coordinate in the Slack channel.",
                  "type": "markdown"
                }
              ],
              "channel": "{{ .outputs.create_slack_channel_medium.slack_channel_name }}"
            }
          },
          "variables": {}
        },
        {
          "identifier": "trigger",
          "title": "Incident Created",
          "icon": null,
          "description": "Triggers when a PagerDuty incident is created",
          "config": {
            "type": "EVENT_TRIGGER",
            "event": {
              "type": "ENTITY_CREATED",
              "blueprintIdentifier": "pagerdutyIncident"
            }
          },
          "variables": {
            "service_id": "{{ .diff.after.relations.pagerdutyService }}",
            "incident_id": "{{ .diff.after.identifier }}",
            "incident_url": "{{ .diff.after.properties.url }}",
            "incident_title": "{{ .diff.after.title }}",
            "incident_status": "{{ .diff.after.properties.status }}",
            "incident_urgency": "{{ .diff.after.properties.urgency }}",
            "incident_priority": "{{ .diff.after.properties.priority }}",
            "incident_description": "{{ .diff.after.properties.description }}"
          }
        },
        {
          "identifier": "update_incident_critical",
          "title": "Update Incident (All Resources)",
          "icon": null,
          "description": "Bulk updates the incident entity with Slack, Zoom, and Jira URLs",
          "config": {
            "type": "UPSERT_ENTITY",
            "blueprintIdentifier": "pagerdutyIncident",
            "mapping": {
              "identifier": "{{ .outputs.trigger.incident_id }}",
              "properties": {
                "slack_channel": "{{ .outputs.create_slack_channel_critical.slack_channel_name // .outputs.create_slack_channel_medium.slack_channel_name}}",
                "zoom_meeting_link": "{{ .outputs.create_zoom_meeting_critical.zoom_meeting_url }}",
                "jira_tracking_ticket": "{{ .outputs.create_jira_ticket_critical.jira_ticket_url // .outputs.create_jira_ticket_medium.jira_ticket_url }}"
              }
            }
          },
          "variables": {}
        }
      ],
      "connections": [
        {
          "description": "Analyze incident severity",
          "sourceIdentifier": "trigger",
          "targetIdentifier": "determine_severity"
        },
        {
          "description": "Critical/High → Create Slack channel",
          "sourceIdentifier": "determine_severity",
          "targetIdentifier": "create_slack_channel_critical",
          "sourceOptionIdentifier": "critical_high"
        },
        {
          "description": "Then get Zoom API acces token",
          "sourceIdentifier": "create_slack_channel_critical",
          "targetIdentifier": "get_zoom_meeting_access_token"
        },
        {
          "description": "Then create Zoom meeting",
          "sourceIdentifier": "get_zoom_meeting_access_token",
          "targetIdentifier": "create_zoom_meeting_critical"
        },
        {
          "description": "Then create Jira ticket",
          "sourceIdentifier": "create_zoom_meeting_critical",
          "targetIdentifier": "create_jira_ticket_critical"
        },
        {
          "description": "Then notify teams",
          "sourceIdentifier": "create_jira_ticket_critical",
          "targetIdentifier": "notify_teams_critical"
        },
        {
          "description": "Finally Bulk update incident with all resources",
          "sourceIdentifier": "notify_teams_critical",
          "targetIdentifier": "update_incident_critical"
        },
        {
          "description": "Medium → Create Slack channel",
          "sourceIdentifier": "determine_severity",
          "targetIdentifier": "create_slack_channel_medium",
          "sourceOptionIdentifier": "medium"
        },
        {
          "description": "Then create Jira ticket",
          "sourceIdentifier": "create_slack_channel_medium",
          "targetIdentifier": "create_jira_ticket_medium"
        },
        {
          "description": "Then notify team",
          "sourceIdentifier": "create_jira_ticket_medium",
          "targetIdentifier": "notify_teams_medium"
        },
        {
          "description": "Finally update incident with Slack & Jira",
          "sourceIdentifier": "notify_teams_medium",
          "targetIdentifier": "update_incident_critical"
        },
        {
          "description": "Low → Notify only",
          "sourceIdentifier": "determine_severity",
          "targetIdentifier": "notify_teams_low",
          "sourceOptionIdentifier": "low"
        }
      ]
    }

  5. Click Publish in the top right corner of the editor. If you encounter validation errors, refer to the troubleshooting page.

Configure the workflow

After publishing, replace placeholder values in the workflow nodes.

Specify Jira project key

  • In the create_jira_ticket_critical and create_jira_ticket_medium nodes:
    • Replace <YOUR_JIRA_ORGANIZATION_URL> in the webhook URL with your Jira organization URL (e.g., example.atlassian.net).
    • Set the <YOUR_JIRA_PROJECT> value to your Jira project key.
    • Ensure that the Jira authorization header is set to Basic {{ .secrets.JIRA_AUTH }}.

Configure Slack

  • In the create_slack_channel_critical, create_slack_channel_medium, and notify_teams_low nodes:
    • Set the authorization header to Bearer {{ .secrets.SLACK_BOT_TOKEN }}.
    • Update the low-priority channel name if needed.

Configure Zoom

In the get_zoom_meeting_access_token node, set the authorization header to Basic {{ .secrets.ZOOM_CLIENT_ID + ":" + .secrets.ZOOM_CLIENT_SECRET | @base64 }}.

Test the implementation​

After you complete either the Workflow or the Actions & Automations setup, use the steps below to verify that orchestration runs correctly.

Create a test incident​

  1. Go to your PagerDuty instance and create a new incident, or use Port's API to create a test incident entity.

  2. Verify that the incident appears in your Port catalog.

Verify execution​

If you used Workflow: Open the run from the Audit log and confirm each node completed successfully. Check node outputs for Slack, Zoom, and Jira responses.

If you used Actions & Automations: Check the AI agent's execution logs in the AI Invocation page. Verify that the agent analyzed the incident severity and executed the appropriate actions (Slack channel, Zoom meeting for high/critical, Jira ticket, notifications).

Verify incident updates​

  1. Go to your Port catalog and find the incident entity.

  2. Check that the incident has been updated with:

    • Slack channel ID
    • Zoom meeting link (if applicable)
    • Jira tracking ticket URL

  3. Verify the links are functional and accessible.

Test in Slack​

  1. Go to your Slack workspace.

  2. Verify that:

    • A new channel was created with the incident identifier
    • Notification messages were posted to the channel
    • The channel contains relevant incident information