In modern software development, we live in a world of specialized tools. Your code lives in GitHub, your sprint planning happens in Jira, and your team communication flows through Slack. While each tool is powerful on its own, the manual effort required to keep them in sync creates a constant, low-level friction—a "sync tax" that drains your team's productivity.
Consider this all-too-common scenario: a developer discovers a bug and opens an issue in a GitHub repository. For that bug to be prioritized and scheduled, a project manager has to manually copy the title, description, and labels into a new Jira ticket. Then, they have to link the Jira ticket back to the GitHub issue. This process is tedious, error-prone, and a complete waste of valuable engineering time.
What if you could eliminate this manual step entirely? What if you could transform this chore into a reliable, instantaneous, and automated workflow?
With issues.do, you can. By treating your issue management as a programmable service, you can build powerful "agentic workflows" that connect your tools and automate your processes as Business-as-Code. Let's walk through how to build a seamless integration that automatically creates a Jira ticket from a new GitHub issue.
The manual sync between GitHub and Jira isn't just annoying; it's actively harmful to your development lifecycle.
issues.do is an Agentic Workflow Platform that acts as the central orchestrator for your development processes. Instead of relying on a UI, you use our simple API and SDKs to define your workflows in code.
For our GitHub-to-Jira pipeline, we'll create a simple agent that:
Let's build this workflow. We'll use TypeScript and the issues.do SDK.
First, we need to tell GitHub to notify our agent when something happens.
Now, every time an issue is opened, edited, or labeled in your repository, GitHub will send a JSON payload to your agent.
Now for the fun part. We'll write the code for our agent. This code will run on the server endpoint you specified in the webhook. For simplicity, let's assume you're using a serverless function.
Our agent will first check if the incoming issue has the label bug. If it does, it will kick off our workflow.
This is where issues.do shines. We'll first create an issue in issues.do to serve as the canonical record of this automated event. This gives us a powerful audit trail. We can even use AI to help categorize or assign it.
Then, we'll use the Jira API to create the corresponding ticket and update our issues.do record with the new Jira ID.
By defining this workflow in code, you've fundamentally upgraded your team's process.
The manual sync between GitHub and Jira is just one of many repetitive tasks that can be automated. Imagine creating workflows that:
By treating issue tracking and project management as a programmable service, you free your team to focus on what they do best: building great software.
Ready to reclaim your team's productivity? Explore issues.do and turn your complex workflows into simple, powerful code.
import { Issue } from '@do-sdk/issues';
import { JiraClient } from './your-jira-client'; // A simple wrapper for the Jira API
// This is the function triggered by your GitHub webhook
export async function handleGitHubIssueEvent(payload: any) {
// Only act on newly labeled issues with 'bug'
if (payload.action !== 'labeled' || payload.label?.name !== 'bug') {
console.log('Event is not a newly labeled bug. Skipping.');
return;
}
const { issue } = payload;
console.log(`New bug detected: "${issue.title}". Initiating workflow...`);
// Let's create a ticket!
await createSynchronizedTickets(issue);
}
// (Continuation of the code above)
async function createSynchronizedTickets(githubIssue: any) {
try {
// 1. Create a canonical record in issues.do
// AI can triage the priority or suggest an assignee based on the content.
const newDoIssue = await Issue.create({
title: `[GitHub Bug] ${githubIssue.title}`,
description: `${githubIssue.body}\n\n*Original GitHub Issue: ${githubIssue.html_url}*`,
project: 'WebApp-Backend',
tags: ['github-sync', 'bug'],
assignee: 'worker.ai' // Let AI assign the best team member in Jira
});
console.log(`Created issues.do ticket: ${newDoIssue.id}`);
// 2. Create the ticket in Jira
const jiraTicket = await JiraClient.createTicket({
projectKey: 'WEB',
summary: githubIssue.title,
description: `${githubIssue.body}\n\n*Synced from issues.do ticket: ${newDoIssue.url}*`,
issueType: 'Bug',
});
console.log(`Created Jira ticket: ${jiraTicket.key}`);
// 3. (Bonus) Update the issues.do ticket with the Jira ticket ID for a complete link
await newDoIssue.update({
metadata: {
jira_key: jiraTicket.key,
jira_url: jiraTicket.url,
}
});
// 4. (Bonus) Comment back on the GitHub issue to close the loop
// This requires a GitHub API client
// await GitHubClient.postComment(githubIssue.number, `✅ Jira ticket created: ${jiraTicket.url}`);
} catch (error) {
console.error('Failed to execute GitHub-to-Jira workflow:', error);
// You could even create a high-priority issues.do ticket to alert an admin
}
}