> 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 if your tool supports it; otherwise present the plan below filled in and wait for my approval. Implement this Port guide in my org via MCP:

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

Read the raw markdown version at https://docs.port.io/guides/all/automatically-resolve-tickets.md - it contains every tab and code block without page markup.

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. If the guide offers alternative implementation paths (tabs), pick the one matching my installed integrations and tools, confirm it with me, and implement only that path.
3. Diff the guide's data model (blueprints, properties, relations, workflows, actions, agents, automations, integrations, webhook data sources, secrets) against mine.
4. Propose adaptations for gaps, reusing existing blueprints/relations over guide-named duplicates.
5. Flag what needs a UI click, credential, or secret from me, testing MCP capability empirically before ruling anything out. If the guide has a "Set up via API" section, use it for anything MCP can't do before treating a step as UI-only.
6. 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.
- Never print secret values into the chat or logs; ask me to set them in Port, or write them via the secrets API without echoing them back.
- 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 and not covered by the guide's API sections, 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:
- Run the guide's "Let's test it" steps where possible (e.g. execute a workflow test run) and confirm the expected output exists 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. A single 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, comments on Jira with the issue link, and sends a Slack notification.

Automatically resolve tickets with coding agents workflow diagram

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 the ... button and then select the Edit blueprint option.

  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 YAML.

  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.
    • GITHUB_ORG - Your GitHub organization or username.
    • SLACK_BOT_TOKEN - Your Slack bot token from the OAuth & Permissions page.

Implementation in Port

The 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. Finally, a Slack message is sent to a channel with the ticket summary. No separate AI agent; the flow is deterministic and visible in the workflow editor.

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 → send Slack message. 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 Name field, enter Autonomous Ticket Resolution With AI, then click Confirm.

  4. On the editor page, click the see workflow JSON button (the code icon) to open the JSON editor.

  5. Copy and paste the workflow JSON below to replace the example workflow.

    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"
        }
      ]
    }

  6. Click Save to save the workflow. 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 the workflow 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 product_approved label and ensure the ticket has an assignee.

  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.

  3. Check the Jira ticket for a comment containing a link to the GitHub issue.

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

More relevant guides