Jira and Git Workflow: A 6-Step Guide for Software Teams
Struggling to connect tickets and code? This 6-step Jira and Git workflow improves traceability from issue to release. Click to discover the steps.
A Jira issue can describe the work, while Git records the code changes, but the two can drift apart. A developer may finish a branch without updating the issue, or a ticket may look complete before its changes are reviewed and merged.
That disconnect creates extra status checks, confusing handoffs, and releases that are harder to trace. When the team cannot quickly connect a request to its code and delivery status, even a small change can cause unnecessary delays.
But here's the truth: a reliable Jira and Git workflow does not require complicated rules. You need a few shared conventions, clear links between issues and code, and a consistent way to move work through review. This six-step guide shows you how to build that workflow, keep it practical, and spot problems before they slow down a release.
A Six-Step Jira and Git Workflow
Use Jira to coordinate work and Git to manage changes to code. Connect them with consistent issue references, branch names, commits, and review habits so each change is easier to understand and track.
-

Agree on how work enters the workflow
Start with a Jira issue that explains the requested change, its purpose, and how the team will recognize completion. Include acceptance criteria, relevant technical context, and any dependencies that could affect delivery.
For example, “Add password reset” is a broad request. “Send a reset link that expires after 30 minutes” gives a developer and reviewer a clearer target.
-
Choose a consistent branch naming pattern
Include the Jira issue key in each branch name. A pattern such as feature/APP-214-password-reset makes the branch easy to associate with its issue.
Agree on prefixes for common work, such as feature/, bugfix/, and hotfix/. Consistency matters more than the exact format; choose one your team can apply without guessing.
-
Reference the issue in commits
Ask developers to include the issue key in commit messages, along with a short description of the change. For example: APP-214 Add reset link expiry check.
That reference helps teammates understand why a change exists when they inspect its history. It also makes it easier to connect related commits to the Jira task during review.
-
Open a pull request or merge request with context
When the change is ready for review, include the Jira issue key and a short explanation in the request. Describe what changed, how you tested it, and anything reviewers should pay attention to.
A reviewer should be able to follow the issue, inspect the branch, and understand the proposed change without chasing the author for basic context. Link the Jira issue directly where your code hosting service allows it.
-
Coordinate review, testing, and issue status
Set expectations for review ownership, required checks, and when Jira status changes. For example, move a task to “In Review” when a pull request is ready, then to “Done” only after the change meets your completion criteria.
Here's why: a status should describe the work's real state. If a ticket is marked complete while its change still awaits approval, Jira becomes less useful for planning.
-
Merge, release, and close the loop
After approval and successful checks, merge the change using your team’s Git practices. Update the Jira issue with the final outcome, and close it only when the agreed completion conditions are satisfied.
If the change is released separately, record that release context in the issue or your team’s chosen workflow. The goal is a clear path from request to implementation and delivery.
Set Conventions That Make Issues and Code Easy to Match
A small set of shared conventions prevents a lot of avoidable detective work. Decide which Jira key format to use, where the key should appear, and what branch prefixes mean.
For example, your team might use APP-214 in the branch name, commit message, and pull request title. That repeated reference gives teammates several ways to follow the same change.
Let me explain: consistency is especially helpful when multiple developers contribute to one issue. If each branch uses a different pattern, a reviewer may miss a related change or mistake it for unrelated work.
Write the conventions somewhere the team can find them, then show examples during onboarding. Keep the rules short enough that people can remember them while working.
Keep Jira Statuses Aligned With Git Activity
Jira status should give an honest view of progress, while Git activity shows the state of a code change. A branch existing does not necessarily mean work is underway, and a merged change does not always mean it is ready for release.
Agree on the events that move work between statuses. Your team might move an issue to “In Progress” when implementation begins, “In Review” when a pull request is ready, and “Done” after approval, checks, and any required release step.
The best part? You do not need to create a status for every small action. A few meaningful stages can help a team spot blocked work more quickly than a long, complicated workflow.
Review exceptions together. If tickets routinely stay in “In Progress” after their branches are merged, clarify who updates the issue and when that update should happen.
Make Code Review Part of the Issue Trail
A Jira issue explains the reason for a change; a pull request shows how the team proposes to implement it. Keep them connected so reviewers can move between the work description and the code without searching manually.
For instance, a pull request for a payment validation change can reference the Jira issue, summarize the behavior being added, and list the test cases run. A reviewer can then compare the implementation with the acceptance criteria.
Use review requirements that fit the risk of the change. A minor text adjustment may need a quick check, while authentication changes might require additional reviewers or tests.
When feedback leads to new commits, keep the issue and review conversation current. That gives the next person a clearer explanation of why the final implementation differs from the original proposal.
Handle Breaks in the Workflow Before They Grow
Some changes will not follow the standard path. A production fix may need an urgent branch, while a shared task might require several branches or pull requests.
Decide how to handle these exceptions in advance. For a hotfix, for example, you might require a Jira issue key, a clear urgency label, and a follow-up review after deployment.
You might be wondering: what if the Jira issue key is missing? Ask the contributor to add the reference to the branch or review request and update the issue with the relevant change details.
When work is blocked by a failed test, missing review, or external dependency, make the blocker visible in Jira. A short note identifying the next action is more useful than leaving the task stalled without explanation.
Use Workflow Reviews to Improve Delivery
Review your Jira and Git process regularly, using concrete examples rather than assumptions. Look for issues that repeatedly wait for review, branches that lack issue references, or completed changes with outdated ticket statuses.
For example, if several small pull requests wait days for approval, the problem may be unclear review ownership. Assigning a rotating reviewer can help without changing the team’s entire process.
Compare a few recent tasks from request through merge. Where did the team pause? Which handoff required extra messages? Those moments often reveal a simple improvement, such as clearer acceptance criteria or a better branch naming rule.
Keep one improvement at a time. If the team changes status rules, naming patterns, and review expectations all at once, it becomes harder to tell which change made the workflow better.
Jira and Git Workflow Support With ONES.com
ONES.com is a unified project management and knowledge management platform powered by ONES Assistant. ONES Project supports project management, while ONES Wiki supports knowledge management; the products are sold separately.

For a team coordinating issues and code changes, the practical value is having project workflows and team knowledge in a connected platform. ONES Project is a Jira alternative with Jira-compatible workflows, while ONES Wiki is a Confluence alternative.
Core Capabilities
- Issue tracking: When work is scattered across conversations, ONES Project provides project management workflows that help teams organize tasks and track progress.
- Jira-compatible workflows: When a team needs familiar issue processes, configurable Jira-compatible workflows help support a transition without requiring every process to be reinvented.
- Custom workflows and fields: When different teams need to capture different details, custom fields and workflows let them shape task handling around their work.
- Sprint management: When teams plan development in iterations, sprint management helps organize work and review progress within each sprint.
- Built-in reporting: When leads need a view of project progress, reporting provides visibility without relying only on manual status updates.
- Automation: When routine workflow actions take repeated effort, automation can reduce manual steps for supported processes.
- Knowledge management: When technical guidance is hard to locate, ONES Wiki gives teams a dedicated knowledge management product alongside project management.
- Deployment choice: When hosting requirements differ, ONES.com offers Cloud, On-Premise, Private Cloud, and Air-gapped deployments, with feature parity between cloud and self-hosted versions.
ONES.com offers a free plan for up to 30 seats. Teams can evaluate whether the available project management and knowledge management products fit their needs, keeping in mind that ONES Project and ONES Wiki are sold separately.
Application Scenarios
A software team standardizing issue workflows: A team moving from informal ticket handling can configure ONES Project workflows and fields, then define how issue keys appear in Git branches and pull requests.
A team with restricted hosting requirements: An organization that needs self-hosting or an air-gapped deployment can consider the deployment options while maintaining access to the platform’s available features.
Common Challenges and Practical Fixes
Branches and pull requests have no Jira reference
Problem: Teammates cannot easily tell which task a code change supports. Solution: Make the issue key part of your branch and review-request conventions, and remind contributors to add missing references during review.
Jira says work is complete before the change is merged
Problem: The board gives an inaccurate view of delivery. Solution: Define what “Done” means and reserve that status for work that meets the team’s completion criteria.
Review requests sit without an owner
Problem: A ready change waits while everyone assumes someone else will review it. Solution: Assign a reviewer or use a rotation, and make review ownership visible in the team’s process.
Urgent fixes bypass normal tracking
Problem: A rushed change can lose its context or follow-up. Solution: Keep an expedited path, but retain the Jira reference and record any post-release review the team requires.
FAQs About Jira and Git
How do Jira and Git work together?
Jira helps a team plan and track work, while Git manages changes to code. The connection usually comes from a consistent issue key used in branch names, commits, and pull requests. Some team setups also link issues and code activity through available integrations. Agreeing on conventions helps teammates follow a task from its description to implementation and review.
Should I create a Jira issue before creating a Git branch?
For planned work, creating or identifying the Jira issue first usually gives the branch a clear purpose and reference. A branch name such as bugfix/APP-214-expiry-check is easier to understand than a generic name. An urgent fix may begin before the issue is fully written, but the team should still capture the work and connect it to Jira as soon as practical.
What should a commit message include?
A useful commit message includes the Jira issue key and a brief description of the change. For example, APP-214 Add reset link expiry check tells a teammate both which task the commit relates to and what it changes. Follow any additional commit conventions your team uses, but keep messages clear enough to make the change’s purpose understandable later.
When should a Jira issue be marked done?
Mark an issue done when it meets the team’s agreed completion criteria. That might mean the change has been reviewed, required checks have passed, and the work has been merged. Some teams also require release confirmation before closing an issue. Choose a rule that reflects how your team delivers software, then apply it consistently so Jira status remains useful for planning.
Conclusion
A dependable Jira and Git workflow connects each task to its branch, commits, review, and completion status. Start with clear issue details, agree on naming conventions, and make review ownership visible.
But here's the truth: the workflow only helps when the team uses it consistently. If issues and code changes keep drifting apart, take one recent example and find the handoff that failed. A small, shared improvement can make the next change easier to track and deliver.