> For the complete documentation index, see llms.txt.
Skip to main content

Check out Port for yourself ➜ 

Automatically resolve tickets with Port

Implement with AI

Send this guide to your coding agent.

Prerequisite: Install Port MCP

Open in ClaudeOpen in CodexOpen in Cursor
Open plan mode. Implement this Port guide in my org via MCP:

https://docs.port.io/guides/all/automatically-resolve-tickets/

Goal: get the guide's core flow working end-to-end in my org; adapting it to fit my existing setup takes priority over matching the guide 1:1.

Plan:
1. Confirm MCP is connected, in the right org, with sufficient permissions.
2. Diff the guide's data model (blueprints, properties, relations, actions, agents, automations, integrations, secrets) against mine.
3. Propose adaptations for gaps, reusing existing blueprints/relations over guide-named duplicates.
4. Flag what needs a UI click, credential, or secret from me, testing MCP capability empirically before ruling anything out.
5. Stop on any blocker and give me options. Approving this plan authorizes the writes it lists; pause only for writes beyond what's listed.

Build:
- Extend blueprint schema additively when upserting; don't remove or overwrite existing properties, and treat type conflicts as a blocker, not an auto-fix.
- List any mock data in the plan, minimal and labeled mock; once approved, seed it without re-asking, and tell me what you seeded.
- For anything the guide writes downstream (e.g. a webhook target), use a real entity, not a mock.
- For pages/widgets, use the real page identifier from the app URL, not a guessed slug.
- When you hit a UI step confirmed (not assumed) unsupported via MCP, pause, give exact clicks, then resume via MCP.
- Validate and give links after each meaningful step (only a tool-returned URL, no guessed paths); don't proceed if the last run wasn't a success.

Done:
- Confirm the guide's expected output exists and runs in Port.
- Summarize adaptations, seeded data, what was mocked or skipped, remaining UI steps, and how to verify.

This guide demonstrates how to automatically resolve Jira tickets using coding agents orchestrated by Port or an n8n workflow enriched with Port context.

Both approaches preserve service ownership, repository, dependency, and documentation context when work moves from Jira to GitHub. They also maintain traceability by linking generated issues and pull requests back to the original ticket.

Common use cases​

  • Create pull requests for bug fixes automatically to reduce repetitive work.
  • Generate GitHub issues from Jira tickets with Port context before assigning them to coding agents.
  • Assign enriched GitHub issues to coding agents such as GitHub Copilot or Claude Code.
  • Preserve organizational context from services, repositories, teams, dependencies, and documentation.
  • Link Jira tickets to GitHub issues and pull requests for end-to-end traceability.
  • Choose Port-native or external orchestration based on your automation environment.

Choose your approach​

Choose coding agents when you want Port to orchestrate ticket resolution directly. Choose n8n when your team already operates n8n or prefers external orchestration.

Use this approach to run ticket resolution with a Port workflow or with Port actions, automations, and an AI agent.

You can implement the Port-native flow in one of two ways:

  1. Workflow - A single Port workflow runs when a Jira ticket moves to In Progress. It enriches the ticket with Port context, creates a GitHub issue, triggers the coding agent, and comments on Jira with the issue link.

  2. Actions & Automations - An AI agent creates GitHub issues from Jira tickets with Port context. Automations invoke the agent and add the pull request link to Jira when the coding agent opens a pull request.

Both options use the same data model and external-tool setup. Only their orchestration differs.

Automatic ticket resolution with coding agents

Prerequisites

This guide assumes the following:

Alternative integrations and coding agents

While this guide uses GitHub and Jira, you can adapt it for other Git providers (e.g. GitLab, Azure DevOps) and project management tools (e.g. Linear). You can also use other coding agents (e.g. Claude Code, Devin) instead of GitHub Copilot for similar automation.

Set up data model

We will configure the necessary blueprints to support our AI-enhanced coding workflow. This involves updating the Jira issue blueprint with necessary relations.

Update Jira issue blueprint

When you install Port's Jira integration, the Jira project and issue blueprints are created by default. However, we need to update the Jira issue blueprint to add the pull request relation and create a mirror property for the PR link.

  1. Go to the builder page in Port.

  2. Find and select your existing Jira issue blueprint (e.g. jiraIssue).

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

  4. Add the following relation to the relations section:

    Pull request relation (Click to expand)
    "pull_request": {
      "target": "githubPullRequest",
      "required": false,
      "many": false
    }

  5. Add the following mirror property to the mirrorProperties section:

    Pull request link mirror property (Click to expand)
    "pull_request_link": {
      "title": "Pull Request Link",
      "path": "pull_request.link"
    }

  6. Click Save to update the blueprint.

Update GitHub integration mapping

To track pull requests opened by Copilot that are meant to fix Jira issues, we need to update the GitHub integration mapping so that a pull request can be linked to the corresponding Jira issue using the Jira issue key in the PR title.

  1. Go to the data sources page in Port.

  2. Find and select your GitHub Ocean integration.

  3. Go to the Mapping tab and click {...} Edit JSON.

  4. Add the following mapping to the mappings section:

    Pull request mapping (Click to expand)
    - kind: pull-request
      selector:
        query: ((.title // "") | test("[A-Z]+-[0-9]+")) and (.user.login == "Copilot")
      port:
        entity:
          mappings:
            identifier: (.title // "") | match("[A-Z]+-[0-9]+").string
            blueprint: '"jiraIssue"'
            properties: {}
            relations:
              pull_request: .id|tostring

  5. Click Save to update the integration configuration.

Set up external tools

We need Jira API access so that the workflow or automations can add comments to Jira issues.

Set up Jira API access

  1. Log in to your Jira instance.

  2. Generate an API token:

    • Go to Atlassian Account Settings.
    • Click Create API token. Ensure the token has permission to update issues and add comments.
    • Copy the generated token (you will need it for the Port secret).

Set up Slack app

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

  2. Add the following permissions to the Slack app:

    • Send messages (required).
      • chat:write.
      • chat:write.public.

  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.

Slack app OAuth and Permissions page

Add Port secrets

To add secrets to Port:

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

  2. Click Credentials.

  3. Click the Secrets tab.

  4. Click + Secret and add the following secrets:

    • GITHUB_TOKEN — A GitHub fine-grained personal access token with read and write permissions for Issues, Metadata, and Pull requests, and Actions (write) for workflow dispatch. Required for the Workflow option; the Actions & Automations option may need it if you use an action that creates GitHub issues via the API.
    • GITHUB_ORG — Your GitHub organization or username. Required for the Actions & Automations option when using the create_github_issue action.
    • SLACK_BOT_TOKEN - Your Slack bot token from the OAuth & Permissions page.

Choose a Port-native implementation

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

  • Workflow — One workflow runs when a Jira issue moves to In Progress with the required label. It calls Port AI for context, creates a GitHub issue, triggers the Copilot assignment workflow, and comments on the Jira issue with the GitHub link. No separate AI agent; the flow is deterministic and visible in the workflow editor.
  • Actions & Automations — You create an AI agent that generates GitHub issues from Jira tickets, and two automations: one that invokes the agent when a Jira ticket moves to In Progress with the copilot label, and one that adds the PR link to the Jira ticket when a related pull request is created.

Build the workflow

Use Port's workflow to run the full sequence: trigger on Jira update → enrich with AI context → create GitHub issue → trigger Copilot → comment on Jira. You can build it with the AI assistant or paste the JSON template.

  1. Go to the workflows page in Port.

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

  3. In the dialog, click Skip to editor to open the workflow editor.

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

    Automatically resolve ticket workflow template (Click to expand)
    {
      "title": "Autonomous Ticket Resolution With AI",
      "icon": "Jira",
      "description": "Automatically generate GitHub issues from Jira tickets with rich organizational context when tickets move to In Progress, assign to GitHub Copilot, and link PRs back to Jira",
      "allowAnyoneToViewRuns": true,
      "nodes": [
        {
          "identifier": "trigger",
          "title": "On Jira Ticket Updated",
          "icon": "Jira",
          "description": "Listens for Jira issue updates and triggers the workflow when a ticket transitions from 'To Do' to 'In Progress', is product-approved, and has an assignee.",
          "config": {
            "type": "EVENT_TRIGGER",
            "event": {
              "type": "ENTITY_UPDATED",
              "blueprintIdentifier": "jiraIssue"
            },
            "condition": {
              "type": "JQ",
              "expressions": [
                ".diff.before.properties.status == \"To Do\"",
                ".diff.after.properties.status == \"In Progress\"",
                "(.diff.after.properties.labels | index(\"product_approved\")) != null",
                ".diff.after.relations.assignee != null"
              ],
              "combinator": "and"
            },
            "published": true
          },
          "variables": {},
          "links": [],
          "verbose": true
        },
        {
          "identifier": "extract_context_with_ai",
          "title": "Extract Context with Port AI",
          "icon": "AI",
          "description": "Invokes Port AI to enrich the Jira issue with contextual data from the Port catalog",
          "config": {
            "type": "AI",
            "userPrompt": "A Jira issue has moved to In Progress.\n\nIssue Details:\n- Key: {{ .outputs.trigger.diff.after.identifier }} \n- Title: {{  .outputs.trigger.diff.after.title }}\n- Type: {{ .outputs.trigger.diff.after.properties.issueType }}\n- Description: {{ .outputs.trigger.diff.after.properties.description }}\n\nRelated Jira Project:\n- Key: {{ .outputs.trigger.diff.after.relations.project }}\n\nYour task:\nQuery the Port catalog using MCP tools to find any related services or repositories connected to this Jira issue.\n\n- Always fetch ALL available properties for each entity\n- Do not limit properties unless explicitly required\n\nExtract ONLY context that actually exists and is directly related via Port relationships.\n\n### Core service context (if available)\n- Service description and tier based on the README\n- Owning team(s)\n- Deployment environments (e.g. prod)\n- Key dependencies (upstream/downstream services)\n\n### Relationship-heavy context (AGGREGATE, DO NOT LIST)\nFor the related service/repository, summarize:\n- PagerDuty incidents:\n  - Total number of open incidents\n- Deployments:\n  - Number of deployments\n  - Environments deployed to\n  - Most recent deployment timestamp (if available)\n- Security vulnerabilities:\n  - Number of open vulnerabilities\n  - Breakdown by severity (e.g. critical / high / medium)\n\nDo NOT include:\n- Raw logs\n- \"None found\" bullet lists\n\nOnly mention a category if at least one related entity exists.\n\nThen prepare:\n1. A GitHub issue title that starts with the Jira key in this exact format: {{ .outputs.trigger.diff.after.identifier }} - <what needs to be done>\n2. A GitHub issue body that:\n- Clearly summarizes the Jira issue in developer-friendly language\n- Adds concise business-relevant Port context (ownership, risk, stability, deploy state)\n- Uses aggregated facts, not exhaustive lists\n- Avoids assumptions or inferred data\n- Is fully self-contained\n\nReturn your response as a JSON object with this exact structure:\n{\n  \"title\": \"<GitHub issue title starting with Jira key>\",\n  \"body\": \"<GitHub issue body with context>\",\n  \"labels\": [\"<Jira key as label>\", \"auto_assign\", \"<additional relevant labels>\"]\n\n\nIMPORTANT OUTPUT CONSTRAINT (HIGHEST PRIORITY)\n- If no relevant Port context exists, use empty strings (\"\") for fields where applicable.\n- You must return ONLY a valid JSON object and nothing else.\n\nOutput format:\nThe response must be parseable by JSON.parse() with no cleanup.\nReturn EXACTLY:\n{\"title\":\"\",\"body\":\"\",\"labels\":[\"\"]}",
            "systemPrompt": "You are a helpful assistant that extracts contextual information from the Port catalogue. You must return ONLY a valid JSON object and nothing else. If you violate this output format, downstream systems will fail.",
            "tools": [
              "^(list|get|search|load|track|describe)_.*"
            ],
            "outputSchema": {
              "type": "object",
              "properties": {
                "body": {
                  "type": "string"
                },
                "title": {
                  "type": "string"
                },
                "labels": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  }
                }
              }
            }
          },
          "variables": {},
          "links": [],
          "verbose": false
        },
        {
          "identifier": "has_ai_context",
          "title": "Has AI Response",
          "icon": null,
          "description": "Checks whether the AI context extraction completed successfully and returned a non-empty response. Prevents downstream actions when AI invocation fails or returns no usable output.",
          "config": {
            "type": "CONDITION",
            "outlets": [
              {
                "identifier": "yes",
                "title": "AI context available",
                "expression": "(.outputs.extract_context_with_ai.response != null)"
              },
              {
                "identifier": "no",
                "title": "AI failed or returned no context",
                "expression": ".outputs.extract_context_with_ai.response == null"
              }
            ]
          },
          "variables": {},
          "links": [],
          "verbose": false
        },
        {
          "identifier": "create_github_issue",
          "title": "Create GitHub Issue",
          "icon": "Github",
          "description": "Creates a new GitHub issue using the Jira issue details and AI-generated context",
          "config": {
            "type": "WEBHOOK",
            "url": "https://api.github.com/repos/<GITHUB_ORG>/<GITHUB_REPO>/issues",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Accept": "application/vnd.github+json",
              "Authorization": "Bearer {{ .secrets.GITHUB_TOKEN }}",
              "X-GitHub-Api-Version": "2022-11-28"
            },
            "body": {
              "body": "{{ .outputs.extract_context_with_ai.response | fromjson | .body }}",
              "title": "{{ .outputs.extract_context_with_ai.response | fromjson | .title }}",
              "labels": "{{ .outputs.extract_context_with_ai.response | fromjson | .labels  }}"
            },
            "onTimeout": "fail",
            "onFailure": "terminate"
          },
          "variables": {},
          "links": [],
          "verbose": false
        },
        {
          "identifier": "comment_on_jira_ai_failure",
          "title": "Comment on Jira – AI Context Failed",
          "icon": "Jira",
          "description": "Adds a comment to the Jira issue explaining that automated GitHub issue creation was skipped because AI context extraction failed, and suggests next steps.",
          "config": {
            "type": "WEBHOOK",
            "url": "https://<YOUR_JIRA_ORGANIZATION_URL>/rest/api/3/issue/{{ .outputs.trigger.jira_key }}/comment",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Accept": "application/json",
              "Content-Type": "application/json",
              "Authorization": "Basic {{ .secrets._JIRA_ATLASSIAN_USER_EMAIL + \":\" + .secrets._JIRA_ATLASSIAN_USER_TOKEN | @base64 }}"
            },
            "body": {
              "body": {
                "type": "doc",
                "content": [
                  {
                    "type": "paragraph",
                    "content": [
                      {
                        "text": "⚠️ Automated GitHub issue creation was skipped because context enrichment failed.",
                        "type": "text"
                      }
                    ]
                  },
                  {
                    "type": "paragraph",
                    "content": [
                      {
                        "text": "What this means:\n• The Jira ticket was detected correctly\n• The AI step did not return usable context\n• No GitHub issue was created to avoid low-quality or incomplete data",
                        "type": "text"
                      }
                    ]
                  },
                  {
                    "type": "paragraph",
                    "content": [
                      {
                        "text": "Next steps:\n• You can retry the automation\n• Or manually create a GitHub issue if work should proceed immediately",
                        "type": "text"
                      }
                    ]
                  }
                ],
                "version": 1
              }
            },
            "onTimeout": "fail",
            "onFailure": "terminate"
          },
          "variables": {},
          "links": [],
          "verbose": false
        },
        {
          "identifier": "trigger_copilot_assignment",
          "title": "Trigger Copilot Assignment Workflow",
          "icon": "Github",
          "description": "Triggers a GitHub Actions workflow that assigns the newly created GitHub issue to GitHub Copilot, enabling AI-assisted implementation.",
          "config": {
            "type": "WEBHOOK",
            "url": "https://api.github.com/repos/<GITHUB_ORG>/<GITHUB_REPO>/actions/workflows/assign_to_copilot.yml/dispatches",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Accept": "application/vnd.github+json",
              "Authorization": "Bearer {{ .secrets.GITHUB_TOKEN }}",
              "X-GitHub-Api-Version": "2022-11-28"
            },
            "body": {
              "ref": "main",
              "inputs": {
                "issue_number": "{{.outputs.create_github_issue.response.data.number | tostring}}",
                "repository_name": "<GITHUB_REPO>",
                "repository_owner": "<GITHUB_ORG>"
              }
            },
            "onTimeout": "fail",
            "onFailure": "terminate"
          },
          "variables": {},
          "links": [],
          "verbose": false
        },
        {
          "identifier": "send_to_slack",
          "title": "Send to Slack",
          "icon": "Slack",
          "description": "Sends a rich, informative Slack notification with workflow summary, automation steps, and quick action buttons",
          "config": {
            "type": "WEBHOOK",
            "url": "https://slack.com/api/chat.postMessage",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Content-Type": "application/json",
              "Authorization": "Bearer {{ .secrets.SLACK_BOT_TOKEN }}"
            },
            "body": {
              "text": "✅ Autonomous Ticket Resolution Complete - {{ .outputs.trigger.diff.after.identifier }}",
              "blocks": [
                {
                  "text": {
                    "text": "✅ Autonomous Ticket Resolution Complete",
                    "type": "plain_text",
                    "emoji": true
                  },
                  "type": "header"
                },
                {
                  "text": {
                    "text": "*{{ .outputs.trigger.diff.after.title }}*",
                    "type": "mrkdwn"
                  },
                  "type": "section"
                },
                {
                  "type": "divider"
                },
                {
                  "text": {
                    "text": "📊 *Workflow Summary*",
                    "type": "mrkdwn"
                  },
                  "type": "section"
                },
                {
                  "type": "section",
                  "fields": [
                    {
                      "text": "*Status:*\n🟢 In Progress",
                      "type": "mrkdwn"
                    },
                    {
                      "text": "*Issue Type:*\n{{ .outputs.trigger.diff.after.properties.issueType }}",
                      "type": "mrkdwn"
                    },
                    {
                      "text": "*Project:*\n<https://app.port.io/jiraProjectEntity?identifier={{ .outputs.trigger.diff.after.relations.project }}|{{ .outputs.trigger.diff.after.relations.project }}>",
                      "type": "mrkdwn"
                    },
                    {
                      "text": "*Assignee:*\n{{ .outputs.trigger.diff.after.relations.assignee }}",
                      "type": "mrkdwn"
                    }
                  ]
                },
                {
                  "type": "divider"
                },
                {
                  "text": {
                    "text": "🚀 *AI-Powered Automation Steps*\n🔍 Context Enrichment from Port Catalog\n🔗 GitHub Issue Created (#{{.outputs.create_github_issue.response.data.number}})\n🤖 Assigned to GitHub Copilot\n🔗 Linked to Jira Ticket",
                    "type": "mrkdwn"
                  },
                  "type": "section"
                },
                {
                  "type": "divider"
                },
                {
                  "type": "actions",
                  "elements": [
                    {
                      "url": "https://app.port.io/jiraIssueEntity?identifier={{ .outputs.trigger.diff.after.identifier }}",
                      "text": {
                        "text": "View Jira Ticket",
                        "type": "plain_text",
                        "emoji": true
                      },
                      "type": "button",
                      "style": "primary"
                    },
                    {
                      "url": "{{ .outputs.create_github_issue.response.data.html_url }}",
                      "text": {
                        "text": "View GitHub Issue",
                        "type": "plain_text",
                        "emoji": true
                      },
                      "type": "button"
                    },
                    {
                      "url": "https://app.port.io/jiraIssueEntity?identifier={{ .outputs.trigger.diff.after.identifier }}&activeTab=2",
                      "text": {
                        "text": "View PRD",
                        "type": "plain_text",
                        "emoji": true
                      },
                      "type": "button"
                    }
                  ]
                },
                {
                  "type": "context",
                  "elements": [
                    {
                      "text": "Powered by Port AI✨",
                      "type": "mrkdwn"
                    }
                  ]
                }
              ],
              "channel": "<SLACK_CHANNEL>"
            },
            "onTimeout": "fail",
            "onFailure": "terminate"
          },
          "variables": {},
          "links": [],
          "verbose": false
        },
        {
          "identifier": "update_jira_with_github_link",
          "title": "Add Comment to Jira Issue",
          "icon": "Jira",
          "description": "Adds a comment to the original Jira ticket containing a direct link to the created GitHub issue, ensuring traceability between Jira and GitHub.",
          "config": {
            "type": "WEBHOOK",
            "url": "https://<YOUR_JIRA_ORGANIZATION_URL>/rest/api/3/issue/{{.outputs.trigger.jira_key}}/comment",
            "agent": false,
            "synchronized": true,
            "method": "POST",
            "headers": {
              "Accept": "application/json",
              "Content-Type": "application/json",
              "Authorization": "Basic {{ .secrets._JIRA_ATLASSIAN_USER_EMAIL + \":\" + .secrets._JIRA_ATLASSIAN_USER_TOKEN | @base64 }}"
            },
            "body": {
              "body": {
                "type": "doc",
                "content": [
                  {
                    "type": "paragraph",
                    "content": [
                      {
                        "text": "✅ GitHub issue created and assigned to Copilot: ",
                        "type": "text"
                      },
                      {
                        "text": "{{ .outputs.create_github_issue.response.data.html_url }}",
                        "type": "text",
                        "marks": [
                          {
                            "type": "link",
                            "attrs": {
                              "href": "{{ .outputs.create_github_issue.response.data.html_url }"
                            }
                          }
                        ]
                      }
                    ]
                  }
                ],
                "version": 1
              }
            },
            "onTimeout": "fail",
            "onFailure": "terminate"
          },
          "variables": {},
          "links": [],
          "verbose": false
        }
      ],
      "connections": [
        {
          "description": "Triggered when a Jira issue meets the workflow criteria and begins AI-based context enrichment.",
          "sourceIdentifier": "trigger",
          "targetIdentifier": "extract_context_with_ai"
        },
        {
          "description": "Routes the AI invocation result into a conditional gate to determine whether downstream actions should proceed.",
          "sourceIdentifier": "extract_context_with_ai",
          "targetIdentifier": "has_ai_context"
        },
        {
          "description": "Continues workflow execution only when AI context extraction succeeds",
          "sourceIdentifier": "has_ai_context",
          "targetIdentifier": "create_github_issue",
          "sourceOutletIdentifier": "yes"
        },
        {
          "description": "Uses the newly created GitHub issue to trigger Copilot assignment.",
          "sourceIdentifier": "create_github_issue",
          "targetIdentifier": "trigger_copilot_assignment"
        },
        {
          "description": "Finalizes the workflow by linking the GitHub issue back to the originating Jira ticket.",
          "sourceIdentifier": "trigger_copilot_assignment",
          "targetIdentifier": "update_jira_with_github_link"
        },
        {
          "description": "Notifies Jira that AI context extraction failed and GitHub issue creation was intentionally skipped.",
          "sourceIdentifier": "has_ai_context",
          "targetIdentifier": "comment_on_jira_ai_failure",
          "sourceOutletIdentifier": "no"
        },
        {
          "description": "Send Slack notification",
          "sourceIdentifier": "update_jira_with_github_link",
          "targetIdentifier": "send_to_slack"
        }
      ]
    }

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

Configure the workflow

After publishing, replace placeholder values in the workflow nodes.

Specify Jira URL and auth

  • Update the Comment on Jira - AI Context Failed (comment_on_jira_ai_failure) and Add Comment to Jira Issue (update_jira_with_github_link) nodes.
    • Replace <YOUR_JIRA_ORGANIZATION_URL> in the webhook URL with your Jira organization URL (e.g. example.atlassian.net).

Specify Slack channel

  • Update the Send to Slack (send_to_slack) node.
    • Replace <SLACK_CHANNEL> in the request body with your preferred Slack channel to receive notification about the automation run.

Configure the GitHub integration

  • Update the Create GitHub Issue (create_github_issue) node.

    • Replace <GITHUB_ORG> with your GitHub organization or username.
    • Replace <GITHUB_REPO> with your repository name.

  • Update the Trigger Copilot Assignment Workflow (trigger_copilot_assignment) node.

    • Replace <GITHUB_ORG> and <GITHUB_REPO> in the webhook URL with the same values.
    • Update the repository_name and repository_owner inputs to match.

Test the implementation

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

Trigger a test Jira ticket update

  1. Go to your Jira instance and find a test ticket.

  2. Add the required label:

    • Workflow: add the product_approved label and ensure the ticket has an assignee.
    • Actions & Automations: add the copilot label.

  3. Move the ticket status from To Do to In Progress.

Verify GitHub issue creation

  1. Go to your GitHub repository.

  2. Verify that a new issue was created with the appropriate title (starting with the Jira key), description, and labels.

  3. Check that the issue has the auto_assign label.

Test pull request linking

  1. Verify that the GitHub issue is automatically assigned to Copilot.

  2. Confirm that a pull request is created (with the Jira ticket key in the title for the Actions & Automations flow).

  3. Check the Jira ticket for a comment: Workflow adds the GitHub issue link; Actions & Automations adds the PR link when the PR is linked to the Jira issue.

Test workflow result
  1. Check the Slack channel for the sent notification. Test workflow result

More relevant guides