Jira is a project management and issue tracking software developed by Atlassian. It is widely used to plan, track, and manage software development and other workflow-based projects.
// Example: A Jira issue might include
{
"issueKey": "PROJ-101",
"summary": "Fix login bug",
"status": "In Progress"
}
Jira was launched in 2002 as a bug and issue tracker. Over time, it evolved into a powerful tool supporting Agile, DevOps, and business workflows across various teams.
Timeline:
- 2002: Jira launched as a bug tracker
- 2010s: Added Agile boards and Jira Service Desk
- 2020s: Cloud-first with advanced automation
Jira Software is for Agile teams. Jira Core targets general business tasks, while Jira Service Management is for IT and support teams managing service requests.
Use Cases:
- Jira Software: Dev teams tracking sprints
- Jira Core: HR tracking employee onboarding
- Jira Service Management: IT handling support tickets
Jira includes features such as customizable workflows, backlog management, issue tracking, roadmaps, reports, and integration with DevOps tools.
Key Features:
- Issue Types (Bug, Task, Story)
- Custom Workflows
- Agile Boards
- Automation Rules
- Advanced Search (JQL)
Jira supports Agile principles by enabling Scrum and Kanban boards, sprint planning, backlog grooming, and reporting like burndown charts.
Agile in Jira:
- Create sprints from backlog
- Track work using boards
- Review team velocity
Scrum in Jira uses fixed-length sprints, while Kanban focuses on continuous delivery with WIP limits. Both are visualized using boards.
Scrum: Plan → Sprint → Review
Kanban: Continuous flow, no fixed iterations
Software teams use Jira for sprints and deployments; business teams (HR, finance) use Jira to track workflows like hiring or invoicing.
- Dev Team: "Implement API endpoint"
- HR Team: "Schedule candidate interview"
Jira Cloud is Atlassian-hosted, scalable, and updated automatically. Jira Server is self-hosted, offering more control but requires maintenance.
Cloud: No infrastructure needed, always up-to-date
Server: Custom plugins allowed, local control
The Jira interface includes dashboards, filters, projects, and boards. Navigation is user-friendly with quick access to issues and reports.
Interface Sections:
- Sidebar: Projects, Boards
- Header: Filters, Create Issue
- Main: Agile Board or Backlog View
- Issue: A single task or bug (e.g., "Fix header layout")
- Project: A container for issues (e.g., "Website Redesign")
- Board: Visual interface for tracking issues (Scrum or Kanban)
// Example Issue JSON
{
"summary": "Create login page",
"type": "Task",
"priority": "High",
"assignee": "Majid"
}
Jira is used by developers, testers, managers, IT support teams, HR departments, finance teams, and more—especially in Agile and DevOps environments.
Users:
- Developer: Track bugs & commits
- Product Manager: Plan releases
- Support Agent: Resolve tickets
Pros: Customizable workflows, Agile support, scalable
Cons: Can be complex, some features behind paywalls
+ Great for team collaboration
- May require training for non-tech users
Use the global search, keyboard shortcuts, and starred filters for efficient navigation. The “Create” button is always at the top to add new issues.
Tips:
- Press "/" to open quick search
- Use "g + i" to go to issues
- Favorite boards for quick access
Jira is used in software development, IT services, healthcare, education, government, marketing, and manufacturing for project and task tracking.
Examples:
- Education: Track student inquiries
- Healthcare: Manage patient support workflows
- DevOps: Automate CI/CD pipelines
To get started: create a project, configure your board, define issue types, invite team members, and begin logging tasks or bugs.
Create your first project
Set up backlog or board
Add your first issue
Invite teammates
Start sprint or Kanban tracking
To use Jira Cloud, visit atlassian.com and sign up with your email. You'll be prompted to create a workspace for your projects.
Steps:
1. Visit Atlassian.com
2. Click "Try Jira Free"
3. Enter email and create a password
4. Choose a site name (e.g., yourteam.atlassian.net)
Jira Cloud is hosted by Atlassian; easy to set up. Jira Server/Data Center is self-hosted and used for full control and privacy.
Cloud: Automatic updates, fast start, monthly pricing
Server: On-premise, full backend control, one-time license
After account creation, Jira will prompt you to create your first project by selecting a template (Scrum, Kanban, etc.).
Project Example:
- Name: Website Redesign
- Type: Scrum Project
- Key: WEB
- URL: yourteam.atlassian.net/jira/software/projects/WEB
Jira offers templates for different use cases. Choose based on your workflow:
Scrum: Sprint planning, backlog, burndown
Kanban: Continuous delivery, no sprints
Bug Tracking: Log, assign, and resolve issues
You can edit your project’s name, key, issue types, workflows, and default assignees from the project settings menu.
Settings > Projects > Your Project > Project Settings
Edit fields like: Issue Types, Screens, Workflows, Fields
Go to “User Management” and invite team members by email. You can assign them specific roles and permissions.
Steps:
1. Go to Admin Panel
2. Click "Invite Users"
3. Enter emails and assign roles (e.g., Developer, Admin)
Permissions control what users can see or do. Define who can create, edit, assign, or transition issues.
Example:
- Developers: Create & assign issues
- Viewers: Read-only access
- Admins: Full control
Jira roles include Administrator, Project Lead, Developer, Tester, etc. Assign roles based on tasks within the team.
Role Examples:
- Admin: Configures workflow, invites users
- Developer: Works on tasks and bugs
- QA: Tests and updates issue status
Group related projects under categories for easy navigation (e.g., Mobile Apps, Web, Internal Tools).
Steps:
1. Go to "Project Settings"
2. Select or create category (e.g., DevOps, HR, Finance)
Integrate Jira with Confluence to attach docs and with Bitbucket to connect source code and deployments.
Examples:
- Confluence: Link meeting notes to an epic
- Bitbucket: View commits linked to Jira issues
Access global settings from the admin panel to manage users, billing, system-wide permissions, and look & feel.
Settings include:
- System
- Products
- User Management
- Issues
- Security
Jira supports multiple languages and time zones. You can set defaults globally or per user.
Steps:
1. Go to Profile > Preferences
2. Set Language: English, French, etc.
3. Set Time Zone: UTC, EST, etc.
Admins can add/remove users, assign groups, reset passwords, and deactivate accounts.
User Directory:
- Groups: Developers, Viewers, Admins
- Users: alice@company.com, bob@company.com
Jira Cloud has Free, Standard, Premium, and Enterprise plans. Choose based on features and team size.
Plan Comparison:
- Free: Up to 10 users
- Standard: Audit logs, 250 GB storage
- Premium: Advanced permissions, sandbox, 24/7 support
Admins can export Jira Cloud data or schedule backups. In Server, regular backup jobs are set via admin console.
Cloud:
- Go to Settings > System > Backup Manager
- Export to ZIP file
Server:
- Configure automatic database backup
An issue in Jira represents a single work item or task, such as a bug, story, or task. It's the basic unit of work in Jira projects.
// Example JSON structure of a Jira issue
{
"key": "PROJ-101",
"fields": {
"summary": "Fix login bug",
"issuetype": { "name": "Bug" },
"status": { "name": "To Do" }
}
}
You can create an issue via the Jira UI, REST API, or integration tools like Slack and GitHub.
// Creating an issue via Jira REST API
POST /rest/api/3/issue
{
"fields": {
"project": { "key": "PROJ" },
"summary": "Implement feature X",
"description": "Detailed implementation plan...",
"issuetype": { "name": "Story" }
}
}
Jira offers different issue types based on the project workflow: Task (general work), Bug (defect), Story (user need), Epic (large effort).
// Issue types
[
{ "name": "Task" },
{ "name": "Bug" },
{ "name": "Story" },
{ "name": "Epic" }
]
Admins can create custom issue types tailored to specific workflows, such as “Design Review” or “QA Approval.”
// Example custom type
{ "name": "Security Review", "description": "Security audit for release" }
Issues can be updated through the Jira UI or REST API to reflect changes in progress, assignee, or content.
// Update issue summary via API
PUT /rest/api/3/issue/PROJ-101
{
"fields": {
"summary": "Fix critical login bug"
}
}
Assigning gives responsibility, while watching allows users to follow updates and comments.
// Assign an issue to a user
PUT /rest/api/3/issue/PROJ-101/assignee
{
"accountId": "user-123"
}
Status shows the issue's progress (e.g., To Do, In Progress, Done). Workflows define allowed status transitions.
// Example workflow: To Do → In Progress → In Review → Done
[
{ "name": "To Do" },
{ "name": "In Progress" },
{ "name": "In Review" },
{ "name": "Done" }
]
Jira issues include fields like summary, description, priority, labels, due date, and custom fields for teams.
// Sample fields JSON
{
"summary": "Update dashboard UI",
"description": "Redesign the dashboard with new charts",
"priority": { "name": "High" },
"labels": ["UI", "Sprint5"]
}
Users can comment on issues and upload attachments to provide context, logs, or visual designs.
// Add a comment
POST /rest/api/3/issue/PROJ-101/comment
{
"body": "Please review the new layout."
}
Linking relates issues such as blockers, duplicates, or related work. Helps visualize dependencies.
// Link issue PROJ-101 to PROJ-102 as “blocks”
POST /rest/api/3/issueLink
{
"type": { "name": "Blocks" },
"inwardIssue": { "key": "PROJ-101" },
"outwardIssue": { "key": "PROJ-102" }
}
Priority indicates importance (e.g., Highest, Low), while severity (often custom) reflects impact of the issue.
// Priority example
"priority": { "name": "Highest" }
Bulk operations allow you to edit, move, transition, or delete multiple issues at once for efficiency.
// Web-based bulk edit: Go to Filters → Advanced Issue Search → Tools → Bulk Change
// Example: Transition all selected issues to “In Review”
Cloning duplicates an issue (excluding history). Moving transfers it to another project or issue type.
// Clone via UI: Click More Actions → Clone
// Move via UI: More Actions → Move
Archiving hides issues from view but keeps history. Deleting permanently removes them and is irreversible.
// Archiving is preferred when you want to retain data
// Deletion should only be done by admins with backup confirmation
The activity section shows comments, status changes, field edits, and user actions over time.
// Accessed via: Issue → Activity → History
// Provides audit trail of all changes made to the issue
A Jira board is a visual interface that displays issues based on filters or projects. It helps teams plan, track, and manage tasks through different statuses and workflows.
// Boards use filters to display issues
// Example: A board for Project = "PROJ" and Sprint = "Current Sprint"
filter = project = PROJ AND sprint in openSprints()
Scrum boards help teams manage work in sprints. They include a backlog, sprint planning, and sprint execution views.
// To create: Go to Jira → Boards → Create Board → Scrum
// Scrum boards support time-boxed iterations and velocity tracking
Kanban boards visualize work as a continuous flow. They don't use sprints but allow tasks to move from To Do to Done at any time.
// To create: Go to Jira → Boards → Create Board → Kanban
// Kanban uses WIP limits to control the number of tasks in each column
Users can switch between board views like Backlog, Active Sprint, or Kanban by clicking the left-hand sidebar or dropdown view selector.
// Scrum: View → Backlog / Active Sprint
// Kanban: View → Board only (no backlog by default unless enabled)
The backlog is where upcoming work is prioritized and refined. Items can be reordered or moved into a sprint.
// Drag issues in the backlog to reorder priorities
// Move issues to sprint area to start planning
This view shows issues currently being worked on in the current sprint. It displays tasks in columns based on their workflow status.
// Columns: To Do → In Progress → Done (customizable)
// Drag-and-drop issues between columns during the sprint
Filters define which issues are shown on a board. You can edit the filter query to include specific criteria.
// Example JQL: project = PROJ AND assignee = currentUser()
Swimlanes divide the board horizontally to group issues by assignee, priority, stories, or JQL conditions.
// Example: Swimlane by Stories groups tasks under their parent stories
// Another option: Swimlane by Assignee or custom JQL
You can rename, reorder, and add workflow columns to match your team’s process. Each column maps to one or more statuses.
// Admin → Board Settings → Columns
// Example: Add "QA" column mapped to "In Testing" status
WIP (Work In Progress) limits restrict how many issues can be in a column at one time, helping teams avoid overload.
// Example: Set WIP limit for "In Progress" to 3
// When exceeded, Jira highlights the column to indicate the breach
Quick Filters allow users to filter board items without changing the global filter. They're useful for personal or temporary views.
// Example: Only show tasks assigned to me
assignee = currentUser()
Clicking an issue on the board opens the detail view, where you can see descriptions, comments, attachments, and transitions.
// Fields shown: Summary, Description, Comments, Assignee, Status, etc.
// You can also transition issues or log work from here
Boards support drag-and-drop for changing issue status, order, or even moving issues between sprints or epics.
// Example: Drag issue from "To Do" to "In Progress"
// This updates the issue status in real-time
Teams can create multiple boards for different views of the same project or for cross-project visibility.
// Scrum board for Team A
// Kanban board for QA team using the same project with a different filter
Board visibility is controlled by permissions. You can share boards with specific users, groups, or the entire organization.
// Share board via: Board Settings → General → Edit Filter Sharing
// Choose: private, project, group, or global
A Jira workflow is a set of statuses and transitions that an issue moves through during its lifecycle, such as from “To Do” to “Done”.
// Simple workflow structure
Statuses: To Do → In Progress → Done
Transitions: Start Progress, Complete Task
Jira provides a default workflow with common states: "Open", "In Progress", "Resolved", "Closed". It cannot be edited directly.
// Default statuses:
[ Open ] → [ In Progress ] → [ Resolved ] → [ Closed ]
You can create your own workflows to match your team's processes using the Workflow Designer in Jira.
// Example custom statuses:
[ Backlog ] → [ Ready for QA ] → [ QA Passed ] → [ Released ]
Transitions: Submit for QA, Pass QA, Release
These are categories for statuses: “To Do” (unstarted), “In Progress” (active), and “Done” (completed).
// Example:
Status: "Backlog" → Category: To Do
Status: "Developing" → Category: In Progress
Status: "Live" → Category: Done
Transitions define how issues move between statuses. Triggers automate transitions based on events (like PR merge).
// Transition: "Start Progress" → From: "To Do" → To: "In Progress"
// Trigger: When GitHub pull request created, move issue to "In Review"
- Conditions control who can transition.
- Validators ensure input validity.
- Post Functions automate actions after a transition.
// Example:
// Condition: Only "Developers" can transition to "In Progress"
// Validator: "Estimate" field must be filled
// Post Function: Assign issue to current user
A Workflow Scheme maps workflows to issue types (e.g., Task, Bug, Epic).
// Example:
Issue Type: Bug → Workflow: Bug Workflow
Issue Type: Task → Workflow: Default Workflow
You can’t edit an active workflow directly. Instead, copy it, make changes, then reassign the scheme.
// Step:
// 1. Copy existing workflow
// 2. Rename (e.g., "Bug Workflow v2")
// 3. Edit transitions/statuses
// 4. Assign to workflow scheme
Status categories group statuses visually: “To Do”, “In Progress”, and “Done”. These affect reports and boards.
// Custom Status: "Needs Review"
// Assign to Category: "In Progress"
// This keeps board columns clean and grouped
Different screens can appear during transitions (like assigning, resolving, or closing an issue).
// Example:
// Transition: Resolve Issue
// Screen: Resolution, Comment, Time Spent
// Assigned via Transition Screen Scheme
- Global workflows are reused across projects.
- Project-specific workflows are customized per project.
// Shared Workflow: "Company Default"
// Custom Workflow: "Marketing Team Workflow" (only for Project MKT)
Use a staging project to test new workflows before applying to production.
// Tips:
// ✔ Create dummy issues
// ✔ Test all transitions and conditions
// ✔ Verify permission schemes
Keep workflows simple, meaningful, and aligned with team processes to reduce friction and confusion.
// Best Practices:
// Use max 5–7 statuses
// Name transitions clearly (e.g., “Send to QA”)
// Automate repetitive transitions with triggers
Add approval steps (manual or automated) before key transitions like deploying or closing an issue.
// Example:
// Transition: "Ready for Deployment" → Needs manager approval
// Status changes only if manager clicks “Approve” transition
Jira maintains history of all changes to workflows and issue transitions for traceability and compliance.
// Use “Issue History” or “Audit Log” to view:
// - Who changed what status
// - When changes happened
// - Workflow edits and version history
Agile focuses on individuals, collaboration, and rapid delivery. Jira supports these values by tracking tasks, enabling communication, and visualizing progress.
Jira provides built-in Scrum boards that support backlog grooming, sprint planning, task tracking, and velocity reporting in a Scrum-friendly environment.
In Jira, sprints are time-boxed events where a team completes a set of issues. You create a sprint in the backlog view and drag issues into it.
// Example: Creating a sprint in Jira UI
// - Go to backlog
// - Click "Create Sprint"
// - Drag stories from backlog into sprint
Burndown charts in Jira visualize remaining work over time. They help track sprint progress and forecast if work will complete on time.
// Interpreting Burndown:
// - Ideal line = steady progress
// - Actual line = current state of completed vs. remaining tasks
Velocity charts in Jira show how many story points a team completes over multiple sprints. This helps with future sprint planning and forecasting.
Jira's Kanban boards support continuous delivery. Limit work in progress (WIP), clearly define columns, and automate transitions when possible.
Epics are large initiatives. In Jira, you create Epics and link smaller user stories to them to track progress across larger goals.
// Example: Creating Epic & linking Stories
// - Create Epic from "Create Issue"
// - Use "Epic Link" in story to connect it
The backlog is where you prioritize tasks. In Jira, product owners drag and rank issues, define scope, and move items into sprints.
During sprint planning in Jira, teams estimate tasks, select stories for the sprint, and assign them. Jira helps track available story points and capacity.
After a sprint, teams reflect on what went well and what can improve. Jira doesn’t host retrospectives directly but links to Confluence or uses comments/tickets to track improvement actions.
Teams can use Jira boards to quickly review what’s in progress, what’s done, and what’s blocked. Filters like “assigned to me” help individuals prepare updates.
Jira provides Agile reports like Velocity, Sprint Burndown, Epic Burndown, and Cumulative Flow to track performance and health of sprints and teams.
Jira supports estimation with story points, time, or t-shirt sizing. Use Planning Poker or Fibonacci scales to standardize team estimations.
// Common Story Point Values: 1, 2, 3, 5, 8, 13
// Example: "Login feature" estimated as 3 points
Jira helps plan and track releases via the “Versions” panel. You assign issues to a version and use it to track release readiness and changelogs.
Agile metrics like lead time, cycle time, velocity, and sprint completion rate can be visualized in Jira or exported to BI tools for analysis.
// Example Metrics:
// - Velocity: Avg. story points completed per sprint
// - Cycle Time: Time from start to done
// - Lead Time: Time from idea to delivery
Dashboards present project status using visual widgets like charts and metrics. You can build them in tools like Jira, Grafana, or custom systems.
// Dashboard layout structure (JSON style)
{
"title": "Project Health",
"widgets": ["velocity", "sprintProgress", "bugCount"]
}
Widgets (or gadgets) show specific metrics such as open issues, recent activity, or team progress.
// Example: Bug count widget configuration
{
"type": "issueCount",
"filter": "project = ABC AND type = Bug AND status != Done"
}
JQL (Jira Query Language) helps filter issues for reporting. You can use it to build dynamic charts and lists.
// JQL to find open tasks for a project
project = ABC AND status != Done AND type = Task
Visual charts show issue distributions and trends. Use pie charts for categories, bar charts for counts, and line charts for timelines.
// Pie chart config: show issues per assignee
{
"type": "pie",
"metric": "assignee",
"filter": "project = ABC"
}
Sprint reports track completed work. Velocity charts show how much the team completes sprint over sprint.
// Example velocity data
[
{ "sprint": "Sprint 1", "committed": 30, "completed": 28 },
{ "sprint": "Sprint 2", "committed": 35, "completed": 33 }
]
Track issue counts by type, priority, or team member using issue statistics reports.
// Stats report by issue type
{
"Bug": 15,
"Task": 22,
"Story": 9
}
Version reports track progress and issue resolution over time for a specific release or milestone.
// Example: version report structure
{
"version": "v2.0",
"completedIssues": 25,
"remainingIssues": 10
}
Time tracking reports display estimated vs. logged hours to ensure work is on schedule.
// Logged time summary
{
"issue": "TASK-101",
"originalEstimate": "4h",
"timeSpent": "3h 30m",
"remaining": "30m"
}
Filters allow users to save custom JQL queries. Subscriptions email reports to users on a schedule.
// Saved filter subscription config
{
"filterName": "Overdue Bugs",
"jql": "project = ABC AND due < now() AND status != Done",
"emailSchedule": "Daily at 9AM"
}
Custom reports use queries, calculated fields, and manual inputs to provide tailored project insights.
// Example: custom chart of story points completed per developer
{
"developer": "Majid",
"storyPoints": 34
}
Dashboards can be shared with specific users, groups, or made public. Permissions control who can edit or view.
// Share settings structure
{
"dashboard": "QA Overview",
"sharedWith": ["team-leads", "qa-group"],
"editableBy": ["admin"]
}
Most tools allow you to export reports in PDF, Excel, or CSV formats for sharing and archiving.
// Example export format
[
{ "Issue": "BUG-101", "Status": "Open", "Assignee": "Majid" },
{ "Issue": "TASK-202", "Status": "In Progress", "Assignee": "Ali" }
]
Tools like EazyBI, Power BI, and Tableau allow deep analytics and dashboards using JSON and REST APIs.
// Connect Jira REST API to Power BI via JSON
GET https://yourdomain.atlassian.net/rest/api/3/search?jql=project=ABC
Use dashboards to track KPIs such as sprint velocity, bug resolution rate, and lead time.
// KPI widget: bug resolution time
{
"metric": "averageResolutionTime",
"project": "ABC",
"timeFrame": "Last 30 Days"
}
Dashboards can update in real time to reflect ongoing activity, using webhooks, polling, or socket data.
// Real-time update via WebSocket
socket.on('update', (data) => {
if (data.metric === 'openIssues') {
updateChart(data.count);
}
});
Jira Query Language (JQL) is a powerful query language used to search for issues in Jira. It allows you to filter, sort, and retrieve issues based on custom criteria.
// Simple JQL example: Find all unresolved issues
status != Done
JQL uses field names, operators, and values to form conditions. Quotes are used for multi-word values.
// Find issues assigned to John
assignee = john.doe
// Issues with "In Progress" status
status = "In Progress"
You can apply saved filters or define custom queries in Jira’s search bar or dashboard gadgets.
// Use a saved filter by ID
filter = 10234
// Use a named filter
filter = "High Priority Bugs"
You can search issues based on their type: Bug, Task, Story, Epic, etc.
// Find all bugs
issuetype = Bug
// Find all stories or tasks
issuetype in (Story, Task)
JQL supports relative and absolute date comparisons for created, updated, due, etc.
// Issues created in the last 7 days
created >= -7d
// Issues updated before Jan 1, 2025
updated < "2025/01/01"
Use logical operators to combine multiple conditions in one query.
// Find open bugs assigned to Alice
issuetype = Bug AND status != Done AND assignee = alice
// Issues not assigned to anyone
assignee IS EMPTY
Sort results by priority, created date, or other fields using ORDER BY.
// Sort issues by creation date descending
project = TEST ORDER BY created DESC
// Sort by priority and then by updated time
ORDER BY priority DESC, updated ASC
You can query custom fields by name or ID if they are configured in your Jira instance.
// Querying a custom field named “Severity”
"Severity" = High
// By ID (e.g. customfield_12345)
customfield_12345 > 3
Search issues based on their link types like “blocks,” “is cloned by,” or “relates to.”
// Issues that block others
issueLinkType = blocks
// Issues that are blocked by specific issue
issue in linkedIssues("PROJ-100", "is blocked by")
Find issues based on who reported or was assigned the issue.
// Issues assigned to Bob
assignee = bob
// Issues reported by Carol
reporter = carol
Reuse complex queries by saving them as filters and referencing them in dashboards or other queries.
// Use a saved filter in another query
filter = "My Open Issues"
Functions enhance queries with dynamic values and group logic.
// Issues assigned to any user in the 'devs' group
assignee in membersOf("devs")
// Issues created today
created >= startOfDay()
// Issues due in next 5 days
due <= endOfDay("+5d")
JQL supports subqueries using IN or NOT IN with other query results.
// Issues in same sprint as another issue
sprint in issuesMatchingQuery("key = PROJ-10")
// Issues assigned to users with unresolved tasks
assignee in issuesMatchingQuery("status != Done")
Use keyboard shortcuts, aliases, and nesting to speed up querying in Jira’s search interface.
// Search for multiple projects at once
project in (MKT, DEV, HR)
// Exclude resolved or closed issues
status NOT IN (Resolved, Closed)
Limit heavy queries, avoid large IN lists, and use indexed fields for faster performance.
// Efficient query using indexed fields
project = "WEB" AND status = "Open" ORDER BY priority DESC
// Less efficient (large text searches)
description ~ "slow performance"
Custom fields allow you to capture specific data tailored to your project needs (e.g., "Customer ID", "Severity").
// Example custom field config in JSON
{
"name": "Customer ID",
"type": "text",
"description": "Track client identifier",
"searchable": true
}
These schemes define how fields behave: hidden, required, or optional in different projects or issue types.
// Field config scheme (simplified)
{
"field": "Priority",
"required": true,
"hidden": false
}
Control which issue types (Bug, Task, Story, Epic) are available in each project.
// Issue type scheme for a project
{
"project": "Customer Support",
"issueTypes": ["Bug", "Task", "Support Request"]
}
Screens define which fields are shown during create, edit, and view operations.
// Screen scheme JSON (simplified)
{
"screen": "Bug Screen",
"operation": "create",
"fields": ["Summary", "Description", "Priority", "Severity"]
}
Set rules for which users or roles receive emails when certain issue events occur (create, update, close).
// Notification scheme
{
"event": "Issue Created",
"recipients": ["Reporter", "Assignee", "Project Lead"]
}
Define who can create, edit, assign, or delete issues. Permissions are tied to roles or user groups.
// Permissions example
{
"project": "Website Redesign",
"permissions": {
"Edit Issues": ["Developers"],
"Assign Issues": ["Project Managers"]
}
}
Change field layout on the issue view screen for better usability and team workflow.
// In Jira: Drag and drop layout designer UI or via REST API (customFieldContext)
Contexts allow fields to behave differently across projects or issue types, with specific defaults.
// Field context config
{
"field": "Severity",
"context": "Support Projects",
"default": "Medium",
"allowedValues": ["Low", "Medium", "High"]
}
Reorder fields to prioritize information display for your users during issue creation or editing.
// Example: Manually reorder in Jira UI or use REST API to set field order // JSON not always applicable but ordering matters in field screen configs
Add new statuses like “QA Review”, “Ready for Deployment” to match your team’s process.
// Status config (conceptual)
{
"name": "QA Review",
"category": "In Progress",
"description": "Waiting on QA team"
}
Global settings affect all projects, while project-level settings allow granular customization.
// Example difference: Global Screen Scheme: used across all projects Project Screen Scheme: specific to "Marketing" project
Use themes, labels, and color coding to highlight priorities, issue types, or workflows visually.
// Example: Use label colors in Jira boards "label": "Urgent", "color": "red"
Use automation rules to move issues automatically based on triggers (e.g., status, field updates).
// Automation rule example (pseudo JSON)
{
"trigger": "Field Changed",
"condition": "Status = In Progress",
"action": "Transition to QA Review"
}
Customize dashboards using filters and gadgets to show relevant JSON-based issue data per user or team.
// Sample gadget configuration
{
"type": "Filter Results",
"filter": "My Open Issues",
"columns": ["Key", "Summary", "Priority"]
}
Jira and other tools offer admin panels to manage schemes, workflows, users, permissions, and JSON API configs.
// Use Jira REST API to view config GET /rest/api/3/field // Returns all fields (custom & system) in JSON
Jira Automation helps automate repetitive tasks, improve workflows, and reduce manual errors by configuring rules that act on issues automatically.
// Example: Basic automation rule triggers on issue creation
{
"trigger": "issue_created",
"actions": [
{ "type": "assign", "user": "project_lead" }
]
}
Jira provides pre-built automation rules like auto-assign, status updates, and notifications that you can enable and customize.
// Built-in rule example: Auto-assign on issue transition
{
"rule": "Assign to Reporter on Transition",
"trigger": "issue_transitioned",
"action": "assign_to_reporter"
}
Triggers start automation when specific events occur, such as issue creation, comments added, or status changes.
// Trigger example: When issue is commented
{
"trigger": "issue_commented"
}
Conditions filter when actions run; actions perform automated tasks like updating fields, sending emails, or transitioning issues.
// Example: If priority is High, then assign to senior dev
{
"condition": { "field": "priority", "equals": "High" },
"action": { "type": "assign", "user": "senior_dev" }
}
Automate transitions between statuses, for example, automatically move issues to “In Progress” when work starts.
// Example rule: Transition issue on comment added
{
"trigger": "issue_commented",
"action": { "type": "transition", "status": "In Progress" }
}
Automatically assign issues based on rules like reporter, component leads, or round-robin assignment.
// Auto-assign based on component lead
{
"condition": { "field": "component", "exists": true },
"action": { "type": "assign_component_lead" }
}
Run automation rules on schedules, e.g., daily checks for overdue issues or weekly reports generation.
// Scheduled rule example: Run every day at midnight
{
"trigger": { "type": "scheduled", "cron": "0 0 * * *" },
"action": { "type": "send_report", "to": "team_lead@example.com" }
}
Automate approval processes, sending approval requests and moving issues based on approval decisions.
// Example approval automation
{
"trigger": "issue_transitioned",
"condition": { "status": "Awaiting Approval" },
"action": { "type": "send_approval_request", "approver": "manager" }
}
Automatically send customized email notifications on issue events or rule triggers.
// Send email on high priority issue creation
{
"trigger": "issue_created",
"condition": { "field": "priority", "equals": "High" },
"action": { "type": "send_email", "to": "alerts@example.com", "subject": "High Priority Issue Created" }
}
Track SLAs with automation to escalate or notify teams when SLAs are about to breach or have been breached.
// SLA breach notification example
{
"trigger": "sla_breached",
"action": { "type": "send_notification", "to": "sla_manager" }
}
Create automation rules that interact across multiple projects, syncing issues or triggering actions in different projects.
// Cross-project automation example
{
"trigger": "issue_created",
"action": { "type": "create_linked_issue", "project": "OtherProject" }
}
Smart Values let you access dynamic issue data like fields, users, or timestamps within automation rules for customized actions.
// Using smart value to include reporter name in email
{
"action": {
"type": "send_email",
"to": "team@example.com",
"subject": "Issue created by {{issue.reporter.displayName}}"
}
}
Templates offer ready-made automation rules that you can import and customize to fit your workflows quickly.
// Example: Using a template to auto-close stale issues
// Template includes trigger, condition for inactivity, and action to close
{
"template": "Auto-Close Stale Issues"
}
Jira automation plans have limits on rule executions per month, so optimizing rules to reduce excessive triggers is important.
// Check usage and optimize rules to stay within limits
// Example: Combine multiple conditions into one rule to reduce executions
Debug automation by reviewing audit logs, checking conditions, and testing rule triggers to find and fix issues.
// Use Jira Automation Audit Log to trace rule executions and errors
// Adjust conditions or actions based on errors found in the log
JSM is Atlassian’s IT service management (ITSM) tool designed to help IT and support teams manage service requests, incidents, changes, and problems efficiently.
// Example of a service request JSON
{
"requestId": "REQ-101",
"type": "Password Reset",
"status": "Open"
}
ITSM focuses on delivering IT as a service using processes like incident management, change management, and service request fulfillment.
Key ITSM Processes:
- Incident Management: Fix disruptions fast
- Change Management: Control IT environment changes
- Problem Management: Identify root causes
JSM categorizes requests (e.g., service requests, incidents, changes) to route and prioritize work correctly.
Common Request Types:
- Incident: Unplanned service interruption
- Service Request: New hardware or access
- Change: Planned update to systems
Customers use customizable portals and forms to submit requests easily without needing Jira access.
// Example: Portal form fields
{
"summary": "Laptop not booting",
"description": "Laptop fails to start after update",
"priority": "High"
}
Queues organize requests for agents, while Service Level Agreements (SLAs) set response and resolution time targets.
Queue Example:
- Priority 1 Incidents
- Password Reset Requests
SLA Example:
- Response Time: 1 hour
- Resolution Time: 4 hours
Integrate Confluence to provide self-service articles linked to common issues, reducing ticket volume.
// Example: Linking KB article to issue
{
"issueKey": "INC-123",
"kbArticle": "How to reset your password"
}
Customers submit and track requests; agents resolve them with assigned permissions.
Roles:
- Customer: Submit/view requests
- Agent: Manage queues, resolve issues
- Admin: Configure JSM projects and workflows
Track and resolve incidents quickly using incident workflows, communication channels, and post-mortems.
// Incident example JSON
{
"incidentId": "INC-456",
"impact": "High",
"status": "In Progress"
}
Manage planned changes with approvals and track recurring problems to find and fix root causes.
Change Example:
- Request change
- Get approvals
- Schedule deployment
Problem Example:
- Identify common incident trends
- Root cause analysis
Automate repetitive tasks like assigning requests, sending notifications, or escalating issues using Jira’s automation rules.
// Example automation rule:
When: New high-priority request created
Then: Assign to senior support agent
And: Send notification email
Use built-in approval workflows and escalation paths to ensure timely decisions and issue resolution.
// Example approval step:
- Manager approval required for hardware purchase
// Example escalation:
- If no response in 2 hours, escalate to team lead
Generate reports on SLAs, queue performance, request types, and agent workload to monitor service quality.
// Sample report metrics:
- Average resolution time: 3 hours
- SLA compliance rate: 95%
- Top request types: Password reset, Software install
Track IT assets like hardware and software licenses linked to requests and incidents for better resource management.
// Example asset JSON
{
"assetId": "HW-789",
"type": "Laptop",
"assignedTo": "Alice"
}
Integrate live chat and email channels so customers can submit and update requests through multiple communication methods.
// Example: Incoming email creates JSM ticket
Email: "Help! My software crashed"
Creates: Incident issue INC-789
Opsgenie provides advanced alerting and on-call management integrated with JSM for effective incident response.
// Example Opsgenie alert triggers JSM incident
Alert: Server down detected
Creates: INC-321 for response team
The Atlassian Marketplace is a platform to find, buy, and install plugins and apps to extend Jira's functionality.
// Visit https://marketplace.atlassian.com/
// Search for plugins by category or use-case
// Examples: Time tracking, reporting, custom fields
Plugins like ScriptRunner, Tempo Timesheets, and Zephyr improve automation, time tracking, and test management.
// ScriptRunner example: automate transitions with custom scripts
// Tempo Timesheets: track time spent on issues
// Zephyr: test case management inside Jira
Connect Jira with Git repositories to track commits, branches, and pull requests linked to Jira issues.
// Link commits to Jira issues by including issue keys in commit messages
// Example commit message: "PROJ-123 Fix login bug"
// Jira will display commit info inside the related issue page
Receive Jira notifications in Slack channels and interact with Jira issues directly from Slack.
// Use official Jira Cloud for Slack app
// Configure notifications for issue updates
// Slash commands example:
// /jira create "New task for frontend" -- creates a Jira issue from Slack
Integrate Trello boards and Confluence pages with Jira for seamless project management and documentation.
// Link Confluence pages to Jira issues for related documentation
// Sync Trello cards with Jira issues using power-ups or plugins
Connect Jira to MS Teams to get notifications, create issues, and collaborate without leaving Teams.
// Install Jira Cloud app for Teams
// Configure channels for Jira alerts
// Use commands to create or update issues inside Teams chats
Time tracking plugins let teams log work hours, track progress, and generate reports.
// Example: Tempo Timesheets
// Log work with time spent and billable hours
// Generate timesheet reports for payroll or billing
Add-ons like Zephyr and Xray manage test cases, executions, and traceability within Jira.
// Create test cases as Jira issues
// Link test executions to stories or bugs
// Generate test coverage reports
Integrate Jira with DevOps tools to track deployments, builds, and automate issue transitions.
// Connect Jira with Jenkins to update issue status on build success/failure
// Use plugins or REST APIs to trigger pipeline runs from Jira
Automate CI/CD workflows by linking Jira issues to build and deploy processes.
// Example: Jenkins plugin sends build results to Jira
// Transition issue to "In Testing" after successful build
Integrate customer relationship management systems (Salesforce, HubSpot) to sync customer data with Jira issues.
// Link customer tickets in CRM with Jira issues for support workflows
// Sync contact info and status updates automatically
Use Zapier to connect Jira with hundreds of apps, automating workflows without coding.
// Example Zap: When a Jira issue is created, send a Slack notification
// Setup triggers and actions visually on Zapier platform
Export Jira data to Power BI for advanced analytics and dashboard visualization.
// Use Jira REST API or plugins to export issues as JSON or CSV
// Import data into Power BI for reports on progress, workload, and trends
Develop custom plugins or scripts exposing REST APIs to extend Jira functionality for your organization's needs.
// Example: Create REST endpoint to fetch issues with custom filters
// Use Atlassian SDK to build plugins in Java or JavaScript
Manage permissions carefully to ensure plugins have appropriate access without exposing sensitive data.
// Assign plugin scopes in OAuth
// Review add-on permissions before installation
// Use Jira permission schemes to control access
Grouping projects into categories helps organize large portfolios by business units, product lines, or teams for easier navigation and management.
// Example categories:
// - Mobile Apps
// - Website Development
// - Internal Tools
// Assign projects to categories via Project Settings → Details
Assigning roles such as Admin, Developer, Tester with specific permissions controls what team members can access or modify.
// Example roles:
// - Project Admin: full control
// - Developer: create/edit issues
// - Viewer: read-only access
Security levels restrict issue visibility to specific users or groups, protecting sensitive information within a project.
// Set security level "Confidential" to limit access to senior managers only
// Assign security levels in issue security schemes
Edit multiple issues at once to save time, like updating statuses, assignees, or priorities.
// Steps:
// 1. Use Issue Navigator to filter issues
// 2. Select multiple issues
// 3. Click "Bulk Change" to apply updates
Epics are large bodies of work broken into smaller stories. Initiatives group multiple epics for strategic planning.
// Epic example:
// Epic: "User Authentication"
// Stories: "Login UI", "OAuth integration", "Password reset"
// Initiatives combine epics across projects for roadmap
Track and manage multiple related projects (programs) or the entire project portfolio with tools like Jira Portfolio (Advanced Roadmaps).
// Visualize dependencies, capacity, and timelines across projects
// Example: Portfolio view showing progress for all teams
Generate reports combining data from multiple teams or projects to monitor progress, risks, and resource allocation.
// Reports include burnup, velocity charts across teams
// Export data for presentations or management
Reuse workflows, screens, and permission schemes across projects for consistency and easier maintenance.
// Create one workflow for issue lifecycle
// Assign it to multiple projects to standardize process
Archive completed or inactive projects to declutter Jira without losing historical data.
// Archived projects become read-only and hidden from search
// Restore projects anytime if needed
Break projects into components (subsections or modules) to assign ownership and track issues more granularly.
// Components example:
// - Frontend
// - Backend
// - API
// Assign issues to components for filtering and reports
Use versions to plan and track releases, link issues to versions, and generate release notes.
// Define versions like "v1.0", "v1.1"
// Assign issues to fix versions
// Track release progress with version reports
Create customized dashboards for stakeholders showing project status, key metrics, and risks.
// Example gadgets:
// - Filter Results
// - Burndown Chart
// - Issue Statistics
Track all changes in issues, workflows, and configurations for audit and accountability.
// Jira logs:
// - Issue status changes
// - Comments added
// - Workflow transitions
Track dependencies between issues or projects to identify blockers and plan accordingly.
// Link issues with "blocks" or "is blocked by" relationships
// Visualize dependencies in Advanced Roadmaps
Monitor risks and compliance tasks by creating issue types or custom fields dedicated to risk management.
// Create custom issue type "Risk"
// Use workflows to track mitigation steps
// Generate reports on compliance status
Global settings control the overall Jira instance behavior including appearance, time zones, and default configurations.
// Access global settings via Jira admin console
// Example: Set default language or timezone
// No direct code, managed via UI or REST API
Site administrators manage instance-wide configurations including project creation, add-ons, and integrations.
// Example REST API call to list all projects (curl)
curl -u admin:API_TOKEN -X GET "https://your-domain.atlassian.net/rest/api/3/project"
Admins create and manage users, assign them to groups for permissions, and control access levels.
// Example REST API to add user to group
curl -u admin:API_TOKEN -X POST \
"https://your-domain.atlassian.net/rest/api/3/group/user?groupname=developers" \
-H "Content-Type: application/json" \
--data '{"accountId":"user-account-id"}'
Control user and group permissions for projects, issues, workflows, and administration actions.
// Permissions set via UI, but can be inspected via REST API
// Example: Get permissions for a project
curl -u admin:API_TOKEN -X GET "https://your-domain.atlassian.net/rest/api/3/permissionscheme"
Track and update Jira licenses, including add-on licenses, to ensure compliance and uninterrupted service.
// License management mostly handled in Jira admin UI
// Check license info via REST API (if available)
Optimize Jira by adjusting JVM settings, database tuning, and add-on performance monitoring.
// Example JVM tuning parameters (jira-config.properties)
-Xms1024m
-Xmx2048m
-XX:+UseG1GC
Implement security measures such as encryption, access controls, and data anonymization to protect Jira data.
// Enforce HTTPS and strong passwords
// Regular audits of user access
// GDPR compliance tools available in Jira Cloud
Audit logs track configuration changes, user actions, and system events for compliance and troubleshooting.
// Access audit logs in Jira admin UI
// Example: Download audit logs for review
Jira provides REST APIs for automation, integrations, and administration tasks.
// Example: Get issue details via REST API
curl -u admin:API_TOKEN -X GET "https://your-domain.atlassian.net/rest/api/3/issue/ISSUE-123"
Configure SMTP servers, notification schemes, and email templates to manage user communications.
// Set SMTP via Jira admin UI
// Customize notifications per project and user preference
Identify and resolve frequent issues like permission errors, indexing problems, and performance bottlenecks.
// Example: Re-index Jira to fix search issues
// Admin UI > System > Indexing > Re-index
Understand differences between self-hosted Jira Server and Atlassian Cloud for administration responsibilities and capabilities.
// Server admins manage infrastructure and upgrades
// Cloud admins focus on configurations and integrations
Use Atlassian tools and guidelines for migrating Jira data between servers or to the cloud.
// Example: Use Jira Cloud Migration Assistant
// Backup data regularly before migration
Plan and execute routine maintenance such as backups, upgrades, and performance reviews to ensure uptime.
// Schedule downtime during off-hours
// Communicate maintenance windows to users
Prepare for failures by implementing backup strategies, testing restores, and creating disaster recovery plans.
// Regularly backup Jira database and attachments
// Store backups securely offsite
// Test restore procedures periodically
Jira is widely used to manage agile projects using Scrum or Kanban boards for sprints, backlogs, and releases.
// Example: User stories tracked as issues with Story Points
{
"type": "Story",
"summary": "Implement login feature",
"storyPoints": 5,
"sprint": "Sprint 10",
"status": "In Progress"
}
Track and prioritize IT support tickets with custom workflows and SLAs to ensure timely resolution.
// Ticket example
{
"type": "Support Request",
"priority": "High",
"status": "Waiting for Support",
"requester": "user@example.com"
}
Use Jira to plan campaigns, track content creation, approvals, and monitor deadlines with custom issue types.
// Campaign task
{
"type": "Task",
"summary": "Create social media ads",
"dueDate": "2025-08-01",
"status": "To Do"
}
Automate employee onboarding workflows, checklist tracking, and documentation collection using Jira issues.
// Onboarding task example
{
"type": "Checklist Item",
"summary": "Setup workstation",
"assignee": "IT Support",
"status": "Done"
}
Manage event tasks such as venue booking, invitations, catering, and post-event follow-up with issue tracking.
// Event logistics issue
{
"type": "Task",
"summary": "Book conference hall",
"dueDate": "2025-09-15",
"status": "In Progress"
}
Track legal cases, compliance deadlines, and audit items with custom fields and workflows.
// Compliance issue example
{
"type": "Compliance Item",
"summary": "Prepare GDPR audit report",
"dueDate": "2025-07-31",
"status": "To Do"
}
Manage product releases, feature requests, and deprecations throughout the product lifecycle in Jira.
// Product issue
{
"type": "Epic",
"summary": "Version 2.0 Release",
"releaseDate": "2025-10-01",
"status": "Planning"
}
Integrate Jira with CI/CD tools to automate builds, deployments, and track incidents.
// Incident linked to deployment pipeline
{
"type": "Incident",
"summary": "Deployment failure on Prod",
"status": "Investigating",
"linkedBuild": "Build #1234"
}
Organize research tasks, grant applications, and publication deadlines using Jira issue hierarchies.
// Research task
{
"type": "Task",
"summary": "Submit journal paper",
"dueDate": "2025-11-01",
"status": "In Review"
}
Coordinate remote teams with transparent task assignments, status updates, and communication via comments.
// Task example
{
"type": "Task",
"summary": "Prepare remote onboarding docs",
"assignee": "Jane Doe",
"status": "To Do"
}
Track multiple projects and programs with portfolio views, resource allocations, and progress tracking.
// Portfolio level issue
{
"type": "Initiative",
"summary": "Q4 Product Expansion",
"projects": ["PROJ1", "PROJ2"],
"status": "Planning"
}
Track patient appointments, medical device maintenance, and compliance using custom Jira workflows.
// Appointment issue
{
"type": "Appointment",
"patientName": "John Smith",
"date": "2025-07-20",
"status": "Scheduled"
}
Manage public service requests, permits, and project tracking with detailed audit logs and permissions.
// Permit application
{
"type": "Permit",
"applicant": "Acme Corp",
"status": "Under Review",
"dueDate": "2025-08-15"
}
Handle course scheduling, student requests, and accreditation tasks with Jira’s flexible issue tracking.
// Course scheduling issue
{
"type": "Task",
"summary": "Schedule Fall semester classes",
"dueDate": "2025-08-01",
"status": "In Progress"
}
Examples of companies successfully using Jira to improve workflows, collaboration, and project delivery.
// Example:
// Spotify used Jira to scale agile across teams,
// improving release cycles and collaboration.
AI in Jira helps automate tasks by learning from past data, improving efficiency and reducing manual work.
Machine learning models can analyze issue attributes to predict and suggest priority levels automatically.
// Example pseudocode for ML-based priority
function predictPriority(issue) {
// Features: issue type, reporter, past similar issues, deadlines
// Model predicts priority: High, Medium, Low
return mlModel.predict(issue.features);
}
AI can recommend the best assignee based on workload, expertise, and past performance.
// Sample logic for predictive assignment
function suggestAssignee(issue) {
const candidates = getTeamMembers();
// Score candidates by expertise and availability
return candidates.sort((a,b) => score(b, issue) - score(a, issue))[0];
}
AI bots can detect routine actions and automate them, like transitioning issues or adding comments.
// Automation rule example:
// If issue type = "Bug" and priority = High, auto-assign to lead
Use NLP to parse user messages or emails to automatically create structured Jira issues.
// Example: Extract title and description from user email text
const nlpResult = nlp.parse(emailText);
createIssue({ title: nlpResult.subject, description: nlpResult.body });
AI analyzes comments to detect urgency, sentiment, or action items for better issue handling.
// Sentiment analysis on comment text
const sentiment = sentimentAnalyzer.analyze(commentText);
if(sentiment.isNegative) alertTeamLead(issueId);
AI suggests improvements to workflows based on historical issue data and bottlenecks detected.
// Suggest to add approval step if many reopens detected
if(issueReopenRate > threshold) suggestWorkflowUpdate("Add Approval Step");
AI models forecast SLA breaches by analyzing issue complexity and team performance.
// Predict if SLA will be missed based on current progress
const willMissSLA = slaPredictor.predict(issue);
if(willMissSLA) notifyManager(issue.id);
AI helps prioritize incidents, suggest resolutions, and route issues to the right teams.
// Incident prioritization based on impact and urgency scores
const priority = incidentModel.predict(incidentData);
assignIncident(priority, bestTeam);
AI defines escalation triggers and automatically escalates issues based on deadlines or severity.
// Auto-escalate if issue unresolved for 48 hours and priority is high
if(issue.status !== 'Resolved' && hoursSinceUpdate > 48 && issue.priority === 'High') escalate(issue.id);
AI evaluates sentiment in comments to flag frustration or confusion early for faster support.
// Flag comments with negative sentiment for review
const sentiment = analyzeSentiment(comment);
if(sentiment < threshold) alertSupportLead(issue.id);
Chatbots powered by AI answer frequent questions and guide users through Jira processes.
// Bot example:
// User: "How to reset my password?"
// Bot replies with instructions automatically
AI automatically applies tags and categories to issues based on content analysis to improve search and filtering.
// Example: Auto-tagging issues mentioning "login" with "Authentication"
if(issue.description.includes("login")) addTag(issue.id, "Authentication");
AI estimates and tracks time spent on issues by analyzing work logs and user activity.
// Predict time to complete based on historical data
const estimatedTime = timeTracker.predict(issue);
displayEstimatedTime(issue.id, estimatedTime);
AI monitors automation rules and bots to detect failures or inefficiencies and suggest improvements.
// Track automation success rates and alert on errors
if(automationErrorRate > 5%) notifyAdmin();
AI APIs allow Jira to enhance automation, natural language processing, and analytics capabilities by integrating external AI services.
// Example: Calling AI API from Jira plugin (pseudo-code)
const response = await fetch('https://aiapi.example.com/analyze', {
method: 'POST',
body: JSON.stringify({ issueDescription: issue.description }),
headers: { 'Content-Type': 'application/json' }
});
const result = await response.json();
console.log(result.analysis);
Use OpenAI’s GPT models to generate summaries, suggestions, or automated responses for Jira issues.
// Call OpenAI API to summarize issue description
const openaiResponse = await fetch('https://api.openai.com/v1/chat/completions', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_OPENAI_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
model: 'gpt-4',
messages: [{ role: 'user', content: issue.description }]
})
});
const data = await openaiResponse.json();
console.log("Summary:", data.choices[0].message.content);
Google Cloud AI services provide NLP, translation, and vision APIs to enhance Jira’s capabilities.
// Example: Use Google Cloud Translation API
const translationResponse = await fetch('https://translation.googleapis.com/language/translate/v2', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
q: issue.description,
target: 'fr',
key: 'YOUR_GOOGLE_API_KEY'
})
});
const translationData = await translationResponse.json();
console.log("Translated text:", translationData.data.translations[0].translatedText);
Azure AI services such as Text Analytics and Computer Vision can be integrated into Jira workflows.
// Example: Using Azure Text Analytics for sentiment analysis
const sentimentResponse = await fetch('https://YOUR_REGION.api.cognitive.microsoft.com/text/analytics/v3.0/sentiment', {
method: 'POST',
headers: {
'Ocp-Apim-Subscription-Key': 'YOUR_AZURE_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({ documents: [{ id: '1', language: 'en', text: issue.description }] })
});
const sentimentData = await sentimentResponse.json();
console.log("Sentiment score:", sentimentData.documents[0].sentiment);
Automate the creation of concise summaries for long issue descriptions using AI.
// Using OpenAI GPT for summarization
const summary = await openai.createChatCompletion({
model: "gpt-4",
messages: [{ role: "user", content: "Summarize this: " + issue.description }]
});
console.log("Summary:", summary.data.choices[0].message.content);
Automatically translate issue descriptions to support global teams using AI translation APIs.
// Google Translate API example (similar to above)
Use AI to improve search relevance in Jira by understanding user intent and natural language queries.
// Pseudocode for AI-enhanced search query
const userQuery = "Show me all urgent bugs";
const enhancedQuery = await aiService.enhanceQuery(userQuery);
const searchResults = await jiraApi.searchIssues(enhancedQuery);
Integrate AI chatbots in Jira to assist users with issue creation, status updates, and FAQs.
// Chatbot listening for commands
chatbot.onMessage(async (msg) => {
if(msg.text.includes("create issue")) {
await jiraApi.createIssue({ summary: msg.text });
chatbot.reply("Issue created!");
}
});
Convert voice notes into text to create or update Jira issues using speech-to-text AI APIs.
// Using Web Speech API for voice to text in browser
const recognition = new webkitSpeechRecognition();
recognition.onresult = (event) => {
const transcript = event.results[0][0].transcript;
console.log("Recognized text:", transcript);
jiraApi.createIssue({ description: transcript });
};
recognition.start();
Use AI to recommend relevant knowledge base articles based on issue content to speed up resolution.
// Example: AI suggesting articles matching issue description
const recommendations = await aiService.getKBRecommendations(issue.description);
console.log("Suggested articles:", recommendations);
Automatically detect and flag duplicate issues using AI similarity detection techniques.
// AI compares new issue text against existing issues for similarity score
const duplicates = await aiService.findDuplicates(issue.description);
if(duplicates.length > 0) {
console.log("Possible duplicates found:", duplicates);
}
Use AI vision APIs to analyze images attached to issues for content tagging or text extraction.
// Azure Computer Vision analyzing image attachment
const imageUrl = issue.attachmentUrl;
const visionResponse = await fetch('https://YOUR_REGION.api.cognitive.microsoft.com/vision/v3.0/analyze?visualFeatures=Description', {
headers: { 'Ocp-Apim-Subscription-Key': 'YOUR_AZURE_KEY' }
});
const visionData = await visionResponse.json();
console.log("Image description:", visionData.description.captions[0].text);
Leverage AI models to predict issue resolution times, risks, and priority for better project management.
// Example predictive model input/output
const prediction = await aiService.predictResolutionTime(issue);
console.log("Predicted resolution (days):", prediction.days);
Deploy custom-trained AI models to address specific Jira automation or analysis needs.
// Upload model and call from Jira workflow
const response = await customAIModel.predict({ issueText: issue.description });
console.log("Custom AI output:", response);
Ensure AI integrations use secure authentication, encrypted data transfer, and comply with data privacy.
// Use HTTPS, API keys, OAuth, and data encryption
fetch('https://secure-ai-api.com/predict', {
headers: {
'Authorization': 'Bearer YOUR_SECURE_TOKEN',
'Content-Type': 'application/json'
}
});
AI algorithms analyze issue data over time to identify trends such as increasing bug reports or feature requests.
// Pseudo-code example of trend detection
const issuesOverTime = [5, 7, 9, 15, 20]; // Number of issues per week
const trend = analyzeTrend(issuesOverTime); // AI function detects upward trend
console.log("Trend is:", trend); // Output: "upward"
AI can flag unusual spikes or drops in issue creation or resolution rates that might need attention.
// Detect anomalies using standard deviation
function detectAnomalies(data) {
const mean = data.reduce((a,b) => a+b) / data.length;
const stdDev = Math.sqrt(data.map(x => (x - mean) ** 2).reduce((a,b) => a+b) / data.length);
return data.filter(x => Math.abs(x - mean) > 2 * stdDev);
}
const anomalies = detectAnomalies([10, 12, 11, 40, 13]);
console.log("Anomalies detected:", anomalies); // [40]
AI models forecast how much work a team can complete in future sprints based on past velocity and issue complexity.
// Predict sprint velocity based on historical data
const pastVelocities = [20, 22, 18, 25, 23];
const predictedVelocity = average(pastVelocities) * 1.05; // Slight optimistic boost
console.log("Predicted sprint velocity:", predictedVelocity);
AI continuously updates velocity forecasts considering team changes, holidays, and past performance.
// Example: Adjust velocity for planned holidays
const baseVelocity = 22;
const holidayImpact = 0.9; // 10% capacity loss
const adjustedVelocity = baseVelocity * holidayImpact;
console.log("Adjusted velocity:", adjustedVelocity);
AI enhances charts by predicting when work will be completed and highlighting bottlenecks.
// Sample burnup data with AI prediction
const completedWork = [5, 10, 15, 20];
const predictedCompletion = 28;
console.log("Predicted total work done by sprint end:", predictedCompletion);
AI identifies risks such as overdue issues or dependencies that could delay releases.
// Identify overdue issues
const issues = [
{id: 1, dueDate: '2025-07-15', status: 'Open'},
{id: 2, dueDate: '2025-07-01', status: 'Closed'}
];
const today = new Date('2025-07-18');
const overdue = issues.filter(issue => new Date(issue.dueDate) < today && issue.status !== 'Closed');
console.log("Overdue issues:", overdue);
AI suggests potential causes of recurring issues by analyzing linked tickets, comments, and code changes.
// Pseudo AI suggestion example
const recurringIssues = ['Login failure', 'Timeout errors'];
const rootCauses = analyzeRootCauses(recurringIssues);
console.log("Suggested root causes:", rootCauses);
AI analyzes comments and messages to gauge team mood and detect potential collaboration issues.
// Using sentiment analysis library on comments
const comments = ["Great job!", "This is frustrating."];
const sentiments = comments.map(c => analyzeSentiment(c)); // e.g., positive, negative
console.log(sentiments); // ["positive", "negative"]
Create dashboards with AI-generated metrics, visualizations, and alerts tailored to your team’s needs.
// Example: Display AI metrics on a dashboard widget
const metrics = {
trend: "upward",
anomalies: 2,
velocity: 24
};
renderDashboard(metrics);
Combine Jira data with BI tools like Power BI or Tableau enhanced with AI capabilities for deeper insights.
// Export Jira JSON data to BI tool
const jiraDataJSON = getJiraData();
biTool.loadData(jiraDataJSON);
AI suggests how to allocate team members based on skills, availability, and workload to maximize productivity.
// Example: AI recommends assignments
const teamMembers = ["Alice", "Bob", "Carol"];
const tasks = ["Frontend", "Backend", "Testing"];
const allocation = aiAllocateResources(teamMembers, tasks);
console.log("Resource allocation:", allocation);
Use AI-powered natural language interfaces to query Jira data and generate reports without complex syntax.
// User input: "Show me open bugs assigned to Alice"
// AI converts to JQL:
const jqlQuery = 'assignee = Alice AND status != Done';
runJQLQuery(jqlQuery);
Track key performance indicators automatically using AI to monitor sprint health, issue resolution, and team performance.
// KPI example: average time to resolve issues
const issueResolutionTimes = [5, 3, 7, 2]; // days
const avgResolutionTime = average(issueResolutionTimes);
console.log("Average resolution time:", avgResolutionTime, "days");
Use charts and graphs to display AI-driven predictions for better decision making.
// Display predicted velocity trend chart using charting library
drawLineChart({
labels: ["Sprint 1", "Sprint 2", "Sprint 3"],
data: [20, 22, 25] // AI predicted velocities
});
AI distills raw data into actionable insights, recommending steps for improving processes or resolving issues.
// Sample AI insight output
const insights = [
"Increase code review frequency to reduce bugs",
"Allocate more testers in sprint 5",
"Address recurring network latency issues"
];
displayInsights(insights);
AI algorithms can automatically generate test cases based on requirements and past test data, increasing coverage.
// Example: AI tool generates test cases from requirements text (pseudo-code)
const requirements = "User login, password reset, profile update";
const testCases = aiGenerateTestCases(requirements);
console.log(testCases);
Machine learning models analyze logs and code commits to detect potential bugs before manual testing.
// Example: ML model flags suspicious commit changes
const commit = getLatestCommit();
const isBuggy = mlModel.predictBug(commit.diff);
if(isBuggy) {
createJiraIssue("Potential Bug detected", commit.details);
}
AI models predict the severity of defects based on historical data, helping prioritize fixes.
// Sample severity prediction
const defectData = { description: "Crash on login", frequency: 10 };
const severity = aiPredictSeverity(defectData);
console.log("Predicted Severity:", severity);
Integrate AI code review tools that analyze pull requests and link findings to Jira issues automatically.
// Pseudo-example: AI flags code smells and links Jira tickets
const review = aiCodeReview(prDiff);
review.issues.forEach(issue => linkToJira(issue, prId));
AI schedules regression tests based on code changes and historical defect patterns to optimize test runs.
// AI suggests test cases to run after commit
const changedFiles = getChangedFiles(commit);
const testsToRun = aiSelectRegressionTests(changedFiles);
scheduleTests(testsToRun);
Analyze code coverage reports with AI to identify untested areas and suggest new tests.
// Analyze coverage data
const coverageData = getCoverageReport();
const gaps = aiFindCoverageGaps(coverageData);
console.log("Coverage gaps:", gaps);
AI tools automatically analyze test results to identify flaky tests, failures, and trends over time.
// Analyze test results logs
const testResults = getTestResults();
const flakyTests = aiDetectFlakyTests(testResults);
console.log("Flaky tests:", flakyTests);
Predict risks associated with releases by analyzing code changes, defect density, and testing results.
// Risk score prediction
const releaseData = collectReleaseMetrics();
const riskScore = aiPredictRisk(releaseData);
console.log("Release risk score:", riskScore);
Use AI to detect tests that fail inconsistently, helping improve test reliability.
// Detect flaky tests based on historical failure patterns
const testHistory = getTestHistory();
const flaky = aiIdentifyFlakyTests(testHistory);
console.log("Flaky Tests:", flaky);
Analyze user feedback and comments linked to Jira issues using natural language processing to find common problems.
// Analyze user comments with NLP
const comments = getUserComments();
const insights = aiAnalyzeSentiment(comments);
console.log("User feedback insights:", insights);
Automatically create or update Jira tickets based on AI-generated QA insights to keep issues tracked.
// Create Jira issues from AI alerts
const alerts = aiGenerateQAAlerts();
alerts.forEach(alert => createOrUpdateJiraIssue(alert));
Plan maintenance tasks by predicting failures or degradations using AI analysis of system logs and test data.
// Predict when components need maintenance
const systemLogs = getSystemLogs();
const maintenanceSchedule = aiPredictMaintenance(systemLogs);
console.log("Maintenance schedule:", maintenanceSchedule);
Continuously monitor software quality using AI to catch issues early during the development lifecycle.
// AI continuously evaluates quality metrics
setInterval(() => {
const metrics = collectQualityMetrics();
aiEvaluateQuality(metrics);
}, 3600000); // every hour
AI generates intelligent alerts prioritized by impact and urgency for QA teams to act on critical issues first.
// AI alerting example
const alerts = aiGenerateAlerts();
alerts.sort((a, b) => b.priority - a.priority);
alerts.forEach(alert => notifyQATeam(alert));
Leverage AI-powered test automation tools that self-adapt and optimize test scripts over time.
// AI tool updates test script automatically
const testScript = loadTestScript();
const optimizedScript = aiOptimizeTestScript(testScript);
runTest(optimizedScript);
AI enhances Agile by predicting sprint outcomes, optimizing backlog prioritization, and automating repetitive tasks.
// Example: AI analyzing sprint velocity data
const sprintData = [20, 22, 18, 25];
const avgVelocity = sprintData.reduce((a, b) => a + b, 0) / sprintData.length;
console.log("Predicted next sprint velocity:", avgVelocity);
ChatGPT-like bots integrated into Jira enable natural language queries, issue creation, and status updates through chat.
// Sample pseudo-code for ChatGPT querying Jira issues
async function askJiraBot(question) {
const response = await chatGPT.query(question);
console.log("Jira Bot Response:", response);
}
AI can autonomously update statuses, assign tasks, and adjust timelines based on progress and dependencies.
// AI auto-assigning issues based on workload
const teamMembers = [{name: "Alice", tasks: 3}, {name: "Bob", tasks: 1}];
const assignee = teamMembers.reduce((a, b) => a.tasks < b.tasks ? a : b);
console.log("Assign to:", assignee.name);
Assistants help users by suggesting issue links, recommending next steps, and sending reminders.
// Assistant suggesting related issues
function suggestRelatedIssues(issue) {
// Query Jira API to find issues with similar tags or summaries
// Return suggestions for user
}
AR could visualize project progress, workflows, and issue statuses in a 3D environment for immersive management.
// Concept: Overlay Jira board in AR glasses
// No code, but imagine 3D kanban cards floating in workspace
AI optimizes build, test, and deployment stages by predicting failures and suggesting fixes.
// Example: AI analyzing build logs to detect flaky tests
function analyzeLogs(logs) {
// Use ML model to identify failure patterns
}
Ensuring AI respects privacy, avoids bias, and operates transparently in Jira workflows is essential.
// Guidelines example:
// Avoid using personal data for automated decisions without consent
// Audit AI decision logs regularly
Providing explanations for AI-driven decisions helps users trust and understand automated actions.
// AI system explains why a task was auto-assigned
const explanation = "Assigned to Alice due to lower current workload and expertise in backend.";
console.log(explanation);
Safeguarding sensitive project and user data when integrating AI is crucial to comply with regulations.
// Encrypt sensitive fields before AI processing
// Ensure compliance with GDPR, CCPA
Low-code tools enable users to create AI-powered automation without deep programming knowledge.
// Visual workflow builder example (conceptual)
// Drag-drop triggers and AI-powered actions
AI facilitates seamless data sharing and coordination between Jira and other tools like Confluence, Slack, and Git.
// AI analyzes Slack messages to update Jira issues automatically
// Example: On Slack keyword “bug”, create linked Jira issue
Cloud and server versions of Jira provide APIs and plugins to embed AI capabilities natively or via third parties.
// Example: Using Jira REST API to feed data into AI platform
fetch('https://yourjira.com/rest/api/2/search?jql=project=AI')
// Process data with AI service
AI automates compliance checks, audit trails, and governance reporting within Jira workflows.
// Auto-generate compliance reports from Jira issue metadata
// Flag issues lacking required approvals
Collect and analyze user feedback with AI to iteratively improve Jira workflows and project outcomes.
// Analyze survey JSON responses to detect trends
const feedback = [{rating: 4}, {rating: 2}, {rating: 5}];
const avgRating = feedback.reduce((a, b) => a + b.rating, 0) / feedback.length;
console.log("Average Feedback Rating:", avgRating);
Train users to collaborate effectively with AI, understand AI outputs, and adapt workflows for AI augmentation.
// Example: Create training modules on AI basics and Jira AI features
// Host workshops and Q&A sessions