Jira Advanced | Administration & JQL for Power Users

In this lesson, we will cover:

• Introduction to JIRA Customization: Opens the discussion on how to tailor JIRA to specific project needs by creating custom fields, workflows, and screens.

• Cautions Against Over-Customization: Emphasizes the potential pitfalls of excessive customization in JIRA. Warns that too many custom fields and workflows can slow down the system, particularly in server versions, and make management more complex.

• Balancing Customization and Standardization: Advises maintaining a balance between customization and standardized solutions across teams. Points out that excessive customization can hinder compatibility and make it difficult to integrate work across different teams or display it on a single dashboard.

• Process Issues vs. Workflow Customization: Discourages using JIRA customization as a fix for process-related issues within teams, suggesting instead to address these problems through team discussions and retrospectives.

• Adhering to the Principle of Minimal Effective Customization: Recommends applying the principle of minimal effective customization—only making changes that are truly necessary and beneficial, and avoiding changes just because they are possible.

In this lesson, we will cover:

• Introduction to Workflow Customization: Discusses the importance of customizing workflows in JIRA to match specific project needs and workflows.

• Caution Against Overcomplicating Workflows: Warns about the pitfalls of creating overly complex workflows with too many statuses, which can make them cumbersome and less user-friendly.

• Mapping Workflow Statuses to Board Columns: Demonstrates how to map various workflow statuses to board columns, ensuring that issues progress smoothly across the board.

• Creating and Editing Workflows: Guides through the process of creating a new workflow, including adding and connecting statuses and transitions, and assigning them to appropriate categories (To Do, In Progress, Done).

• Assigning Workflows to Projects: Shows how to assign a newly created workflow to a project, either by editing an existing workflow scheme or creating a new one, and how to handle the transition of existing issues to the new workflow statuses.

• Practical Tips on Workflow Design: Offers practical advice on designing workflows that are effective and user-friendly, emphasizing the need for simplicity and clarity in workflow creation.

In this lesson, we will discuss:

• Setting Up Rules for Workflow Transitions: Explains how to implement specific rules for each transition in a JIRA workflow, enhancing control over how issues move through different stages.

• Accessing Workflow Settings: Guides on how to access and edit workflows either directly from project settings or via the 'Issues' menu for more precision.

• Configuring Triggers, Conditions, Validators, and Post Functions:

  • Triggers: Actions or events that initiate a status transition.

  • Conditions: Criteria that must be met for a transition to occur.

  • Validators: Checks that ensure all necessary conditions are satisfied before a transition is completed.

  • Post Functions: Actions that are automatically performed after a transition is completed, such as updating issue fields or statuses.

• Practical Application of Workflow Customization: Demonstrates how to apply these settings in a workflow, using an example of a book editing process to illustrate the creation and connection of various statuses and transitions.

• Importance of Balanced Customization: Emphasizes the need to maintain a balance in workflow customization, avoiding overcomplication and ensuring that real-life processes and team agreements are reflected accurately in JIRA settings.

In this lesson, we will cover:

• Introduction to Custom Fields in JIRA: Discusses the versatility and freedom offered by custom fields, enabling more tailored project management.

• Considerations Before Creating Custom Fields: Emphasizes thoughtful planning before adding custom fields, considering how they fit into the project's workflow and issue types.

• Creating and Configuring Custom Fields:

  • Demonstrates how to create a custom field (e.g., a 'Triager' role) using the user picker field type.

  • Guides through assigning the custom field to specific screens and projects.

• Managing Custom Field Contexts and Default Values:

  • Shows how to set up different configurations for custom fields based on project or issue type.

  • Illustrates how to apply default values and user filtering to custom fields for specific project contexts.

• Implications of Custom Fields in Advanced Issue Search: Verifies the functionality of the new custom field in JIRA's advanced issue search.

• Balancing Customization with Practicality: Advises caution in creating custom fields to avoid overcomplication and management challenges, underscoring the importance of aligning custom fields with real team needs and processes.

In this lesson, we will discuss:

1. Understanding JIRA Screens: Explains screens as a feature defining which fields are visible in different views or actions within a JIRA issue.

2. Managing Screens: Demonstrates how to add or remove fields from a screen, including the custom field 'Triager' created earlier.

3. Screen Schemes and Operations: Introduces screen schemes, which associate particular screens with different issue operations like creating, editing, or viewing issues.

4. Issue Type Screen Schemes: Describes how these schemes specify which screen scheme applies to each issue type within a project.

5. Creating and Utilizing Custom Screens: Shows how to create a new screen (e.g., 'Assign Screen') and integrate it into a workflow, highlighting the additional control over which fields are presented during specific issue transitions.

6. Differences in Team Managed Projects: Highlights the simpler, more direct approach to managing fields and workflows in team-managed projects compared to company-managed projects, with a focus on the local scope of changes.

In this lesson, we will delve into Jira Query Language (JQL), an essential tool for advanced data filtering and issue management in Jira:

• Introduction to JQL: JQL's role as a key feature in Jira is highlighted, emphasizing its strength in creating sophisticated filters for Jira issues.

• Scope of JQL: JQL's capability to handle a wide range of fields and operators, including those from custom fields and third-party plugins, is discussed.

• Importance of JQL for Jira Admins: The critical role of JQL for Jira administrators is emphasized. A strong understanding of JQL is deemed crucial for troubleshooting and resolving team queries and issues effectively.

• Practical Application of JQL: The session aims to equip learners with the ability to read, write, and troubleshoot JQL queries efficiently, enhancing their problem-solving skills in a Jira environment.

In this lesson, the focus is on understanding and using Jira Query Language (JQL) effectively:

1. JQL Overview: JQL is presented as a key feature of Jira, enabling precise and customized issue searches through advanced filtering capabilities.

2. Basic Search vs JQL: The distinction between basic search and the more advanced JQL is highlighted, emphasizing JQL's capacity for dealing with complex queries.

3. JQL Components: The components of JQL, including fields, operators, values, and keywords, are introduced and explained. The importance of correctly using these elements to construct queries is stressed.

4. Field Operators in JQL: Various field operators like 'equal to', 'not equal', 'in', and 'not in' are discussed, with examples demonstrating their use in filtering projects and other criteria.

5. AND, OR, ORDER BY in JQL: The lesson explains the use of logical operators AND, OR, and the sorting operator ORDER BY in JQL. It highlights the importance of correctly ordering these operators in a query.

6. Using JQL Effectively: Tips are provided on how to use JQL efficiently, such as relying on Jira's suggestions for field names and operators to avoid errors.

7. Practical Application of JQL: The session concludes with a demonstration of creating a JQL query, including saving and utilizing the query for different purposes such as creating boards or dashboards.

In this lesson, the focus is on using Jira Query Language (JQL) for people-related fields:

1. Exploring People-Related Fields: The lesson starts by identifying fields related to people in JIRA, such as Assignee, Reporter, and custom fields like Triager.

2. Assignee Field Queries: Demonstrates how to create JQL queries to find issues based on the 'Assignee' field. This includes using the 'equal to' operator to find issues assigned to specific individuals and combining it with other criteria using 'AND'.

3. Group Membership Queries: Shows how to use JQL to find issues assigned to members of a specific group using the 'members of' function.

4. Former Assignee Queries: Introduces the 'was' operator in JQL, which is useful for identifying issues that were previously assigned to a particular individual. This includes filtering based on specific dates using 'AFTER', 'BEFORE', and other temporal operators.

5. Combining Criteria: The lesson demonstrates combining different criteria, like finding issues that were once assigned to a specific person but are currently assigned to someone else.

6. Practical Application: The session includes practical examples, such as dealing with team members moving to different teams or organizations, and needing to reassign their issues.

7. Tips for Writing JQL: Emphasizes the importance of understanding JQL syntax and recommends using JIRA's autocomplete feature for field names and operators to avoid errors.

In this lesson, the focus is on using Jira Query Language (JQL) to find issues based on their status:

1. Understanding JQL with Statuses: The lesson begins with an overview of JQL, emphasizing its importance in Jira for creating custom filters. The focus is on understanding how to use JQL for querying issues based on their status.

2. Basic Status Queries: Demonstrates how to use JQL to search for issues in specific statuses, like 'Open' or 'To Do'. The instructor uses the 'IN' operator for multiple statuses and '=' for a single status.

3. Combining Status with Other Criteria: Shows how to combine status queries with other fields like labels. For instance, finding issues in 'Open' or 'To Do' status that also have an 'Urgent' label.

4. Practical Exercise: Encourages viewers to pause the video and try writing a JQL query themselves that fits the given criteria, aiming to enhance practical understanding.

5. Advanced Status Queries: Introduces the 'WAS' operator for querying issues based on their past statuses. The lesson includes an example of finding issues that were 'Open' on a specific date but are now in a different status.

6. Real-life Use Cases: Discusses how these queries can be applied in real-life scenarios, such as reassigning tasks when a team member leaves or changes roles.

7. Query Refinement and Verification: Emphasizes refining queries to get precise results and verifying them by checking against known issues to ensure accuracy.

In this lesson, the focus is on understanding and using Jira Query Language (JQL) to manage issue links in Jira:

1. Understanding Issue Links: The lesson begins with an explanation of different types of issue links in Jira, such as epic links, subtasks, and various other link types (e.g., "blocks," "is blocked by," "duplicates," "is duplicated by").

2. Creating and Managing Links: Demonstrates how to create links between issues and the importance of correctly linking issues for accurate project management. For example, linking an issue as being blocked by other issues.

3. Searching for Linked Issues in JQL: Shows how to use JQL to find issues based on their links. This includes finding issues linked to a specific issue, issues with a certain type of link, and issues linked by specific link types like "duplicates" or "is duplicated by."

4. Practical Examples of Link Searches: Provides practical examples and encourages viewers to write JQL queries for specific link-related scenarios. This hands-on approach helps to understand the nuances of issue linking in Jira.

5. Advanced Link Query Techniques: Introduces more advanced JQL functions for linked issues, such as linkedIssues function, which allows more detailed queries based on issue links.

6. Importance of Accurate Linking: Emphasizes the importance of accurate issue linking in project management and how JQL can be used to create useful filters and manage dependencies and blockers effectively.

7. Troubleshooting and Tips: Offers troubleshooting tips for common issues encountered while querying linked issues, such as checking both sides of a link type and ensuring correct usage of link types in JQL queries.

In this lesson, the focus is on utilizing Jira Query Language (JQL) to filter issues based on various time-related parameters:

1. Understanding Time in JQL: The lesson starts by explaining the basic use of time in JQL, including the use of specific time-related fields like 'createdDate', 'updatedDate', and 'dueDate'.

2. Basic Time Queries: Demonstrates how to construct JQL queries for finding issues created or updated within certain time frames. It covers using operators like 'more or equal', 'less or equal', and direct date inputs.

3. Relative Time Queries: Shows how to use relative time expressions in JQL, like 'startOfDay()', 'endOfDay()', 'startOfMonth()', 'minus X days/weeks', etc. This allows users to create dynamic queries that adjust according to the current date.

4. Specific Date Formats in JQL: Emphasizes the importance of using the correct date format in JQL queries, and advises checking Jira's error messages for the correct syntax when encountering issues.

5. Future Dates Queries: Explains how to query issues based on future dates using the 'dueDate' field. This is useful for identifying upcoming deadlines or tasks.

6. Combining Time with Other Criteria: Suggests ways to combine time-based filters with other criteria, such as issue status or assignee, to create more complex and useful queries.

7. Practical Applications: Discusses practical applications of these queries, such as decluttering boards by filtering out old issues or focusing on recently updated items.

In this lecture, the focus is on creating complex JQL (Jira Query Language) queries, particularly when filtering issues based on multiple parameters:

1. Complex Query Example: The lesson starts with an example query that filters issues either assigned to specific users (Jane Doe or another user represented by a code) or issues that have a specific label ('book cover').

2. Adding Additional Parameters: Demonstrates adding another condition (status open) to the query. It explains how the 'OR' operator splits the query, resulting in issues that either match the first set of conditions (assignee) or the second condition (label and status).

3. Using Parentheses to Group Conditions: Shows how to group conditions using parentheses to ensure the query logic is executed correctly. This technique is essential when combining multiple criteria to produce the desired results.

4. Creating Readable Queries: Discusses the use of line breaks in queries for better readability and manageability, similar to coding practices.

5. Building on a Master Query: Introduces the concept of a master query as a base for boards, reports, and dashboards. The lesson shows how to create a new query based on this master filter and add additional conditions to it.

6. Using the 'Filter' Field in JQL: Explains how to use the 'filter' field in JQL to reference an existing filter (e.g., 'base filter') and add new conditions to it, such as a specific status.

7. Considerations for Large Jira Instances: Warns about the potential performance issues when creating very complex queries or using multiple references in large Jira instances with thousands or millions of issues.

In this lecture, the focus shifts to addressing a common issue in JIRA related to organizing epics and creating an additional level of hierarchy.

1. Grouping Epics Together:

   • The lecture begins by discussing the need for an additional hierarchy level above epics, termed as 'super epics.'

   • It suggests using color-coding for epics to visually group related epics together.

   • Another approach is to create a new issue that acts as a 'super epic' to group several related epics.

2. Creating and Linking 'Super Epics':

   • Demonstrates creating a 'super epic' as a regular story issue.

   • Emphasizes the importance of team agreement and understanding of what a 'super epic' signifies.

   • Explains linking epics to the 'super epic' using the 'RelatesTo' link type.

3. Querying Linked Epics:

   • Shows how to query all issues under epics linked to a 'super epic' without specifying each epic.

   • Uses the 'linkedIssues' function in JQL, demonstrating how to query issues linked to the 'super epic.'

4. Using ScriptRunner for Enhanced JQL:

   • Introduces ScriptRunner as a powerful plugin for JIRA that allows more advanced JQL functions and scripting capabilities.

   • Covers the installation and initial configuration of ScriptRunner.

   • Illustrates using ScriptRunner’s enhanced JQL to query issues in epics with a shared label or characteristic, offering a more straightforward approach than the 'super epic' workaround.

5. Limitations and Recommendations:

   • Notes the limitation of ScriptRunner’s enhanced JQL with team-managed (next-gen) projects.

   • Recommends using company-managed projects for more flexibility and integration with ScriptRunner.

   • Encourages exploring ScriptRunner's full potential beyond enhanced JQL.

In this lecture, the focus is on ensuring that the filters created in previous sections are properly set up and saved for future use:

1. Saving Filters:

   • Emphasizes the importance of saving filters for later use.

   • Recommends developing a naming convention for filters to keep them organized, especially for JIRA administrators who create numerous filters. For instance, using a combination of team name, project name, and a brief description of the filter.

2. Including Epics in Filters:

   • Highlights the need to include epics in filters, especially if the filter is intended for use in boards or dashboards. This ensures that epics themselves are also captured in the filter results.

   • Demonstrates how to modify the filter to include epics by using the ‘linkedIssues’ function and the relevant issue key.

3. Editing Filter Details and Permissions:

   • Stresses the importance of reviewing and editing the filter details, including permissions.

   • Advises setting filters to be accessible to the organization, unless there are reasons to keep them more restricted.

   • Explains how to add other users as editors of the filter, a feature beneficial for collaborative work and continuity during absences.

4. Using ScriptRunner for Enhanced JQL:

   • For those who installed and are using ScriptRunner, the lecture shows how to save an enhanced JQL search as a filter in ScriptRunner.

   • Notes the differences in using ScriptRunner between JIRA Cloud and JIRA Server.

5. Sharing and Syncing Filters:

   • Provides guidance on sharing filters with all logged-in users, unless there's a need for more restricted access.

   • Highlights the importance of keeping filters in sync, especially when they are used as a foundation for boards.

In this lesson, we will cover:

• Introduction to Key JIRA Tools: Providing an overview of the essential tools and features in JIRA that teams use daily.

• Importance of Understanding JIRA Tools: Emphasizing the significance of being proficient in JIRA tools, whether you are a JIRA administrator, team leader, or team member.

• Encouragement for Hands-on Practice: Urging learners to apply the knowledge in a practical context, using real-life examples and scenarios from their organizations.

• Support and Guidance: Offering assistance through the Q&A section for any queries or challenges faced while learning about these tools.

In this lecture, we'll cover:

• Introduction to Scrum Boards: A review of Scrum boards in JIRA and their significance.

• Requirement of a Filter for Scrum Boards: The importance of setting up a filter before creating a Scrum board.

• Issues with Team Managed Projects: Challenges and bugs encountered in Team managed projects, particularly regarding filter results.

• Creating a Scrum Board: Steps to create a Scrum board, including choosing between Scrum or Kanban and associating it with a filter.

• Scrum Board Settings for JIRA Admins: Key settings in Scrum boards that JIRA admins need to be aware of.

• Troubleshooting Common Board Issues: Solutions for common problems such as missing issues and configuring columns.

• Board Customization Options: Exploring the customization features available in Scrum boards, including quick filters and card colors.

• Importance of Consistency in Settings: The need for consistency in settings across different boards for effective prioritization.

• Integration of Scrum and Kanban Elements: Understanding how Scrum boards incorporate Kanban elements and vice versa.

In this lecture, we're focusing on creating and customizing a Kanban board in JIRA, using the same filter as for the Scrum board. Here are the key points:

1. Creating the Kanban Board: We start by selecting the Kanban board option and using the existing 'Book Cover Team Base' filter.

2. Initial Board Setup: The default Kanban board has 'To Do', 'In Progress', and 'Done' columns. We note an issue with epics being mixed with other issues.

3. Customizing Board Settings: We access the board settings to modify filters, general settings, and the display of epics. The importance of having the board ordered by rank is emphasized.

4. Kanban Backlog: We explore adding a Kanban backlog for better visibility and prioritization of tasks.

5. Troubleshooting Issue Movements: We encounter an issue where tasks couldn’t be moved to 'To Do', leading to a check of workflow settings.

6. Workflow and Columns Alignment: The alignment of workflow statuses with board columns is critical. We adjust the workflow to match the board's columns.

7. Setting Column Constraints: Work-in-progress limits are set for columns to manage task flow better.

8. Utilizing Swim Lanes: Swim lanes are introduced for better organization, which can be based on assignees or other JQL queries.

9. Other Board Customizations: Like Scrum boards, Kanban boards can be customized with quick filters, card colors, and card layouts.

10. Epic Panel Utilization: Enabling the epic panel separates epics from main tasks on the board.

In this lecture we will discuss the process of setting up dashboards.

1. Basics of Dashboard Creation: How to start building a dashboard in JIRA, including naming conventions and defining access permissions.

2. Choosing and Configuring Gadgets: Exploring different gadgets available in JIRA, and how to customize them for specific data display needs.

3. Audience and Purpose Consideration: Understanding the target audience for the dashboard and tailoring the information and layout accordingly.

4. Advanced Gadget Features: Diving into more complex gadgets like Two Dimensional Filter Statistics for enhanced data visualization.

5. Effective Dashboard Layout: Strategies for organizing gadgets in a dashboard for clarity and ease of use.

6. Practical Application and Best Practices: Tips on using dashboards effectively within a team or organization, and best practices for maintaining clear and useful JIRA dashboards.

In this lesson, we will cover the following key points related to JIRA Roadmaps:

1. Navigating to Different Boards: Instructions on how to locate and access various boards (like Scrum and Kanban) within a JIRA project.

2. Overview of Roadmaps: Exploring the functionality and purpose of roadmaps in JIRA, particularly useful for projects with clear milestones and a waterfall approach.

3. Managing Epics and Dependencies in Roadmaps: Guidance on how to arrange epics on a timeline, adjust their duration, and set dependencies between them.

4. Utilizing Sprints in Roadmaps: Integrating sprint planning within the roadmap, highlighting how issues can be assigned to specific sprints.

5. Customizing Roadmap Views and Filters: Tips on adjusting the roadmap view (by months, quarters, weeks) and applying filters based on labels, status categories, or assignees.

6. Troubleshooting and Best Practices: Addressing common issues with roadmaps, such as the limitations in team-managed projects and adapting roadmaps for multi-project views.

In this lesson, we'll delve into the following aspects of JIRA Charts and Reports:

1. Reports Access and Availability: Guidance on locating reports in JIRA, with a focus on using Scrum boards for a broader range of reporting options compared to Kanban boards.

2. Understanding JIRA Charts: An overview of how charts are generated for each board and what they represent, highlighting their automatic generation in JIRA.

3. Filter-Based Report Generation: Emphasis on the importance of filters in generating accurate reports and how issues appearing on boards are reflected in the charts.

4. Column and Status Mapping in Reports: Explanation of how charts like the Cumulative Flow Diagram are influenced by board settings, particularly the mapping of statuses to columns.

5. Report Customization and Refinement: Tips on refining reports, including changing time frames and applying filters for more targeted data visualization.

6. Key Charts and Their Usage: Recommendations on which charts to utilize, such as the Burn Down Chart, Sprint Report, Velocity Chart, Cumulative Flow Diagram, Control Chart, and Epic Report, with a focus on their relevance to Agile methodologies like Scrum and Kanban.

In the upcoming lesson, the focus will be on understanding and effectively utilizing story points in JIRA:

1. Concept of Story Points: Explaining story points as a method for estimating work in terms of effort, time, and uncertainty.

2. Fibonacci Scale for Estimation: Highlighting the use of the Fibonacci scale (1, 2, 3, 5, 8, 13, 20, etc.) for assigning story points in JIRA.

3. Application Across Industries: Demonstrating the adaptability of story points beyond software development to sectors like retail, banking, and digital marketing.

4. Sprint Planning with Story Points: Showcasing how to plan sprints in JIRA by assigning story points to issues and aligning them with the team's velocity.

5. Tracking Progress with Story Points: Illustrating the use of story points for tracking progress in sprints and epics, and adjusting sprints accordingly.

6. Interpretation in JIRA Reports: Discussing the reflection of story points in various JIRA reports like the velocity chart and cumulative flow diagram, providing insights into team performance.

7. Best Practices and Usage Tips: Advising on the importance of adhering to the intended use of story points for accurate reporting and efficiency.

In this lesson, the focus is on guiding you through the process of setting up a JIRA project from scratch, tailored to a team's specific needs. The scenario involves an HR team requiring a new JIRA project with unique requirements. The main points to be covered are:

1. Understanding Team Requirements: Analyzing the HR team's needs for handling various tasks like hiring, employee status changes, HR investigations, and daily minor tasks.

2. Configuring Issue Types and Workflow: Setting up suitable issue types (e.g., 'Employee' for HR-related tasks) and creating a workflow that matches the team's process, including stages like Open, To Do, Initial Screening, etc.

3. Custom Field Creation: Implementing a custom field for 'Employee Number' in the project to cater to the HR team's specific data tracking needs.

4. Ensuring Project Visibility and Privacy: Adjusting settings to restrict project visibility only to the HR team members, ensuring confidentiality.

5. Setting Up Approvals and Permissions: Configuring the workflow and permissions to require head of HR approval for specific tasks, such as employee status changes or HR investigations.

6. Practical Implementation and Testing: Demonstrating the setup process within JIRA, testing each step to ensure it aligns with the HR team’s requirements.

7. Fine-Tuning and Feedback Incorporation: Continuously refining the setup based on trial usage and feedback from the HR team, ensuring the solution is practical and user-friendly.

In this lesson, we will explore various additional tools, integrations, and plugins available for JIRA, some of which may be paid. The focus is on demonstrating setup options and enhancing your proficiency with JIRA through diverse functionalities.

In this lecture, we'll cover:

• Overview of JIRA Automations: Exploring the automation features available in JIRA for enhancing project efficiency.

• Setting Up Permissions for Automation: The necessity of configuring permissions for Atlassian add-on project access users to enable automation functionalities.

• Creation of a New Automation Rule: Demonstrating the process of creating a new automation rule in JIRA, including selecting triggers and conditions.

• Utilization of Components in Automation: How to effectively use components in JIRA automation to streamline tasks.

• Action Configuration in Automation Rules: Setting up specific actions within an automation rule and understanding their impact on project workflow.

• Testing and Troubleshooting Automations: Strategies for testing new automation rules and troubleshooting common issues to ensure optimal performance.

• Refining Automation Rules: Fine-tuning automation rules based on testing outcomes for maximum efficiency.

• Importance of Testing Changes Individually: Emphasizing the significance of testing one change at a time to identify the effects of each modification accurately.

• Recommendation for Using a Test Instance of JIRA: The benefits of having a separate test instance of JIRA for experimenting with automation rules before implementing them in the main project environment.

In this lecture, we'll cover:

• Introduction to Confluence: Understanding Confluence as a separate Atlassian tool and its integration capabilities with JIRA.

• Setting Up Confluence in JIRA: Steps to enable and configure Confluence integration in a JIRA project.

• Navigating the Confluence Interface: Exploring the basic features and layout options within Confluence for content creation and organization.

• Linking JIRA and Confluence: Demonstrating how to connect JIRA issues and filters directly within Confluence pages for enhanced project documentation and tracking.

In this lecture, we will cover:

• Role and Responsibilities of a JIRA Super Admin: Exploring the extensive capabilities and critical responsibilities of a JIRA Super Admin.

• System Settings and Global Configuration: How to access and modify the general configuration settings for the entire JIRA instance.

• Audit Log Utilization: The importance of monitoring the audit log for tracking administrator actions.

• Global Permissions and User Management: Managing global permissions and user access across the JIRA platform.

• Automation and Issue Collectors: Understanding the role of global automation and setting up Issue Collectors for feedback.

• Backup and Import Tools: Utilizing JIRA's backup manager and import tools for data management and migration.

• Customization Options: Customizing the look and feel of JIRA and managing announcement banners for all users.

In this lecture, we will explore:

• Integrating JIRA with Slack: The process of connecting JIRA to Slack for enhanced communication and project tracking.

• Enabling Slack Integration in Project Settings: How to activate the Slack integration feature directly from JIRA project settings.

• Authorizing and Configuring Slack Workspace: Steps to authorize and link a specific Slack workspace and channel to a JIRA project.

• Customizing Notification Settings: Adjusting notification preferences in Slack to receive updates about specific JIRA issue activities.

• Utilizing Advanced Slack Integrations: Exploring additional Slack integration options available in the JIRA marketplace for extended functionalities.

In this concluding lecture, we'll cover key recommendations and practices for effective JIRA administration:

• Advance Planning for JIRA Structure: Emphasizing the importance of strategic thinking in setting up user groups, categories, and projects for streamlined management.

• User Group Setup: The necessity of creating and managing JIRA user groups for efficient user management.

• Utilization of Epics: Encouraging the use of epics for better project organization and filtering.

• Effective Use of Story Points: Advocating for the adoption of story points in projects for insightful reporting.

• Board and Dashboard Setup: Tips on customizing boards and dashboards to meet team needs and preferences.

• Filter Creation and Testing: Guidance on creating and rigorously testing JIRA filters for accuracy and efficiency.

• Prudent Customization: Advising caution in over-customizing JIRA to avoid unnecessary complexity and maintenance challenges.

• Workflow and Process Alignment: Highlighting the need to align JIRA workflows with team processes, rather than using JIRA to dictate processes.

• Preference for Company Managed Projects: Recommending the use of company-managed projects for broader functionality and stability.

In this final lecture of the course, the focus is on encouraging further practice and continuous learning to master JIRA:

• Emphasis on Practice: The importance of practical experience in JIRA administration is highlighted, encouraging learners to actively engage with JIRA, whether in a test environment or in actual projects.

• Building Relationships with Current Admins: For those aspiring to become JIRA admins, the advice is to establish a good rapport with existing administrators. This can lead to gradual involvement and expansion of administrative responsibilities.

• Using Personal Projects for Practice: Suggesting the use of personal or shared projects for continual practice and skill enhancement.

• Continued Learning and Community Engagement: Recommending continuous education in Agile methodologies and staying updated with the latest developments in JIRA through community engagement and resources like the Atlassian blog.

• Encouragement to Share and Network: Incentivizing course participants to share their course completion and network, with an offer to endorse JIRA skills on LinkedIn for those who tag the lecturer in their post.