Can this sync existing GitHub issues that are already in milestones?

No, GitHub webhooks only fire on new milestone assignments. You'd need to run a one-time import using GitHub's List Issues API to catch existing milestone assignments.

What happens if I rename a GitHub milestone after issues are synced?

The Jira tickets keep the old milestone name in labels. GitHub doesn't send rename events, so you'd need a separate scenario watching milestone changes to update existing tickets.

Can I sync Jira ticket status changes back to GitHub?

Yes, but requires a separate scenario with Jira webhooks. Watch for status transitions and use GitHub's API to add comments or labels to the linked issue.

How do I handle GitHub issues assigned to multiple milestones?

GitHub only allows one milestone per issue, but if you use labels for additional sprint planning, add those to the Jira labels field using Make's array iterator module.

What if my Jira project requires custom fields during ticket creation?

Add them to the Jira module configuration. Most custom fields accept static values or GitHub data mappings. Use Jira's REST API documentation to find required field formats.

Beginner~12 min setupDeveloper Tools & Project ManagementVerified April 2026

How to Sync GitHub Milestones with Jira Sprints with Make

Automatically sync GitHub milestones with Jira sprints and create or link tickets when issues are added to milestones.

Steps and UI details are based on platform versions at time of writing — check each platform for the latest interface.

Make

Also on:Zapier N8n Power-automate Pipedream

Best for

Development teams using GitHub for code and Jira for sprint planning who need automatic ticket creation when issues join milestones.

Not ideal for

Teams syncing more than 1000 issues monthly or those needing real-time synchronization under 30 seconds.

Sync type

polling

Use case type

sync

Real-World Example

💡

A 12-person SaaS development team uses this to automatically create Jira sprint tickets when product managers add GitHub issues to release milestones. Before automation, the dev lead manually copied 40-60 issues per sprint from GitHub to Jira, taking 2 hours and often missing issues or duplicating work. Now milestone assignments trigger ticket creation within 5 minutes.

What Will This Cost?

Drag the slider to your expected monthly volume.

Monthly workflow runs

/mo

505005K50K

Each platform counts differently — Zapier: 1 task per trigger. Make: 1 operation per module per record. n8n: 1 execution per run.

$30/mo if billed monthly

Pipedream

$29/mo

Basic plan

Prices shown for annual billing. Based on published pricing as of April 2026.

Estimated ROI

1000

min saved/mo

$583

labor value/mo

Free

no platform cost

Based on ~2 min manual effort per operation at $35/hr fully loaded labor cost.

Implementation

Skip the setup

Import this workflow directly into Make

Copy the pre-built Make blueprint and paste it straight into Make. All modules, filters, and field mappings are already configured — you just need to connect your accounts.

Before You Start

Make sure you have everything ready.

Admin access to both GitHub repository and Jira project

GitHub repository with milestones configured for sprint planning

Jira project with appropriate issue types and fields available

Jira API token generated for your account

Make account with available operation quota

Field Mapping

Map these fields between your apps.

Field	API Name	Description
Required
Issue Title	`title`	GitHub issue title becomes Jira ticket summary
Milestone Name	`milestone.title`	GitHub milestone becomes Jira label or fix version for sprint tracking
Issue Number	`number`	GitHub issue number for linking back in Jira comments
Issue URL	`html_url`	Direct link to GitHub issue added to Jira ticket comments

4 optional fields▸ show

Issue Description	`body`	GitHub issue body content maps to Jira description field
Assignee	`assignee.login`	GitHub assignee username for Jira assignee field mapping
Labels	`labels`	GitHub labels array transferred to Jira labels for categorization
Repository Name	`repository.name`	Source repository name added to Jira for multi-repo environments

Step-by-Step Setup

Scenarios > Create new scenario > GitHub

Create new scenario in Make

Set up your workspace and initialize the automation scenario. This creates the foundation for connecting GitHub and Jira.

1Log into Make and click 'Create a new scenario'
2Click the large '+' button in the center
3Search for 'GitHub' in the app list
4Select 'Watch Issues' trigger

✓ What you should see: You should see a GitHub module as the first step in your scenario with a gear icon for configuration.

GitHub Module > Connection > Add

Connect GitHub account

Authenticate with GitHub to access your repositories and milestones. Make needs read access to issues and milestones.

1Click 'Add' next to the Connection field
2Select 'GitHub' connection type
3Click 'Continue' to open GitHub OAuth
4Authorize Make to access your repositories
5Name your connection 'GitHub Production'

✓ What you should see: A green 'Connected' status appears next to your connection name in the dropdown.

⚠

Common mistake — Don't use a personal access token connection - OAuth gives better error messages when rate limits hit.

Make settings

Connection

Choose a connection…Add

click Add

GitHub

Authorize Make

popup window

✓

Connected

green checkmark

GitHub Module > Configuration

Configure GitHub issue watching

Set up the trigger to monitor when issues are added to milestones. This watches for milestone assignment events specifically.

1Select your repository from the Repository dropdown
2Set State filter to 'All'
3Set Event to 'milestoned'
4Leave Assignee field empty to watch all issues
5Set Limit to 10

✓ What you should see: The module shows your repository name and 'milestoned' event selected.

⚠

Common mistake — Setting Event to 'opened' will trigger on all new issues, not just milestone assignments - you'll get noise.

Make

click +

search apps

GitHub

Configure GitHub issue watch…

GitHub

module added

Scenario > Add Module > Jira Software

Add Jira connection

Connect to your Jira instance to create and link tickets. Make supports both cloud and server Jira instances.

1Click the '+' button after the GitHub module
2Search for and select 'Jira Software'
3Choose 'Create an Issue' action
4Click 'Add' for Connection
5Enter your Jira URL, email, and API token

✓ What you should see: A Jira module appears connected to GitHub with a green connection status.

Jira Module > Project Configuration

Configure Jira project mapping

Map your GitHub repository to the correct Jira project and issue type. This determines where new tickets get created.

1Select your Jira project from the Project dropdown
2Choose 'Story' as the Issue Type
3Set Priority to 'Medium'
4Leave Reporter as default (you)

✓ What you should see: The project name and issue type display in the module configuration panel.

⚠

Common mistake — Don't select 'Epic' as issue type - most GitHub issues map better to Stories or Tasks for sprint planning.

GitHub fields

title

body

state

html_url

user.login

available as variables:

1.props.title

1.props.body

1.props.state

1.props.html_url

1.props.user.login

Jira Module > Field Mapping

Map issue fields

Connect GitHub issue data to Jira fields. This ensures issue titles, descriptions, and metadata transfer correctly.

1Click in the Summary field
2Select 'title' from GitHub data
3Click in Description field
4Select 'body' from GitHub data
5Add GitHub issue URL to Comments field

✓ What you should see: Field mappings show blue tags like {{1.title}} and {{1.body}} in the Jira fields.

Jira Module > Labels and Versions

Add milestone to sprint mapping

Connect GitHub milestones to Jira sprints using custom fields or labels. This keeps your sprint planning synchronized.

1Scroll to Labels section in Jira module
2Click 'Add item' for Labels array
3Map to GitHub milestone title: {{1.milestone.title}}
4Add static label 'github-synced'
5Set Fix Version to milestone title if available

✓ What you should see: Labels section shows two entries: milestone title mapping and 'github-synced' static text.

⚠

Common mistake — If your Jira doesn't have Fix Versions enabled, skip that field - the scenario will fail otherwise.

Add Module > Jira > Search for Issues

Add duplicate prevention

Check if a Jira ticket already exists for this GitHub issue to avoid creating duplicates during sync.

1Add a new Jira module before Create Issue
2Select 'Search for Issues' action
3Use JQL: summary ~ '{{1.title}}' AND project = YOUR_PROJECT
4Set Maximum results to 1

✓ What you should see: A Search module appears between GitHub and Create Issue with your JQL query configured.

⚠

Common mistake — Don't search by description - GitHub issue titles are more reliable for duplicate detection than body text.

Add Module > Flow Control > Router

Configure conditional logic

Use a router to either create new tickets or update existing ones based on the search results.

1Add a Router module after the Search
2Connect one path to Create Issue
3Add filter: {{2.issues}} is empty
4Connect second path to Update Issue
5Add filter: {{2.issues}} exists

✓ What you should see: Router shows two paths with filter conditions: one for empty results, one for existing issues.

⚠

Common mistake — Filters are the most common place setups break. Double-check the field name and value exactly match what your app sends — a single capital letter difference will block everything.

GitHub

trigger

filter

Condition

matches criteria?

yes — passes through

no — skipped

Jira

notified

Scenario > Run once

Test with sample data

Run the scenario with a test GitHub issue to verify field mapping and Jira ticket creation work correctly.

1Click 'Run once' at the bottom
2Add a GitHub issue to a milestone in your repo
3Watch the scenario execution in real-time
4Check that a Jira ticket was created
5Verify all fields mapped correctly

✓ What you should see: Execution shows green checkmarks on all modules and a new Jira ticket appears with GitHub data.

⚠

Common mistake — If execution fails on the first run, check your Jira permissions - Make needs create issue and edit issue rights.

Make

▶ Run once

executed

✓

GitHub

✓

Jira

🔔 notification

received

Module > Properties > Error Handling

Set up error handling

Configure what happens when API calls fail or rate limits are hit. This prevents the scenario from breaking in production.

1Right-click each module and select 'Properties'
2Set Error handling to 'Break'
3Add a WebHook module after Router for error notifications
4Configure retry settings: 2 attempts with 1 minute intervals

✓ What you should see: Each module shows a small exclamation mark indicating error handling is configured.

⚠

Common mistake — Don't set error handling to 'Ignore' - you'll lose failed syncs silently and wonder why tickets are missing.

Scenario > Toggle > Scheduling

Activate scenario

Turn on automatic execution so the scenario runs whenever GitHub issues are added to milestones.

1Click the toggle switch at bottom left
2Set scheduling to 'Immediately'
3Save the scenario with name 'GitHub-Jira Sprint Sync'
4Click 'OK' to confirm activation

✓ What you should see: The scenario shows 'ON' status and begins monitoring for new GitHub milestone events.

Drop this into a Make custom function.

JavaScript — Custom Function{{if(1.milestone.title; 1.milestone.title; "No Sprint")}} - Use this in Jira labels to handle issues without milestones gracefully instead of leaving blank fields.

▸ Show code

{{if(1.milestone.title; 1.milestone.title; "No Sprint")}} - Use this in Jira labels to handle issues without milestones gracefully instead of leaving blank fields.

... expand to see full code

{{if(1.milestone.title; 1.milestone.title; "No Sprint")}} - Use this in Jira labels to handle issues without milestones gracefully instead of leaving blank fields.

Scaling Beyond 300+ issues per sprint+ Records

If your volume exceeds 300+ issues per sprint records, apply these adjustments.

Batch API calls

Use Make's aggregator to group multiple GitHub issues into single Jira API calls. This reduces operation count by 60% and prevents rate limit issues.

Add processing delays

Insert 30-second sleep modules between GitHub webhook and Jira calls. High issue volumes can overwhelm Jira's API even within rate limits.

Split by repository

Create separate scenarios for different repositories to distribute load. Use filters based on repository name to route issues to appropriate Jira projects.

Going live

Production Checklist

Before you turn this on for real, confirm each item.

Test scenario with issues that have no milestone assigned to verify filtering works

Applies when: Always

Verify Jira user account has create and edit permissions for target project

Applies when: Always

Set up webhook URL monitoring to catch GitHub delivery failures

Applies when: High volume

Configure scenario timeout to 40 seconds for large issue descriptions

Applies when: Always

Enable detailed execution logging for first week to catch field mapping errors

Applies when: Always

Add rate limit handling with 60-second delays between API calls

Applies when: High volume

Troubleshooting

Common errors and how to fix them.

Frequently Asked Questions

Common questions about this workflow.

Analysis

VerdictWhy Make for this workflow

Use Make for this if you need visual debugging and your team creates 50+ issues per sprint. Make's router system handles the duplicate checking logic better than Zapier's branching, and you can see exactly where data transforms fail. The module library covers both GitHub webhooks and Jira's full API. Skip Make if you're syncing more than 1000 issues daily - N8N handles bulk operations faster and costs less at high volume.

Cost

This workflow uses 4 operations per GitHub issue: webhook trigger, Jira search, create/update issue, and error handling. At 200 issues per month, that's 800 operations monthly. Make's Core plan at $9/month includes 10,000 operations, so you're well under the limit. Zapier would cost $20/month for the same volume since their Starter plan only includes 750 tasks. N8N cloud runs $20/month but gives unlimited executions.

Tradeoffs

Zapier's Jira integration includes sprint field mapping that Make lacks - you have to use labels or custom fields instead. N8N lets you write custom JavaScript for complex milestone-to-sprint logic that Make's visual editor can't handle. But Make's error recovery is superior - when Jira API calls fail during sprints, Make retries automatically while Zapier just logs the failure. For most teams, the visual debugging outweighs the sprint field limitation.

GitHub's milestone webhook fires twice if you change the milestone date after assigning issues - your scenario will try to create duplicate Jira tickets. The search-before-create pattern catches this, but adds API calls to your quota. Jira's API returns cryptic field errors that don't mention the actual field name - enable Make's detailed logging to see the full request body. GitHub issues with 2000+ character descriptions will hit Jira's field limits and fail silently unless you truncate the body text in Make first.

Ideas for what to build next

→
Add Slack notifications for new sprint tickets — Send a message to your dev team channel whenever GitHub issues create new Jira tickets, including milestone and assignee information.
→
Sync Jira ticket completion back to GitHub — Close GitHub issues automatically when linked Jira tickets move to Done status, keeping both systems current.
→
Create milestone progress tracking — Build a dashboard scenario that counts open vs closed tickets per milestone and posts weekly sprint progress to project management tools.