In this lesson, you’ll learn:

• The key differences between team-managed and company-managed Jira projects.

• Why this course focuses on company-managed projects as a best practice.

• How to create a company-managed Scrum project from scratch.

• The importance of choosing the right project key and what it means for your issues.

• When you might prefer team-managed projects instead—and the trade-offs involved.

In this lesson, you’ll learn:

• The structure of a Jira instance, and how it organizes projects and teams.

• The three-tiered hierarchy in Jira: Epics → Issues → Subtasks.

• The difference between common issue types like user stories, tasks, bugs, and custom issue types.

• How issue linking works, including parent-child relationships and limitations.

• Why understanding this hierarchy is crucial for effective Jira use.

In this lesson, you’ll learn:

• How to create Jira issues using both the project board and the global create button.

• The difference between epics, user stories, tasks, bugs, and subtasks, and when to use each.

• How to organize your backlog by assigning issues to epics—either by menu selection or drag-and-drop.

• Tips for managing issue details, customizing fields, and using issue keys effectively.

• How to visually categorize epics using colors and why that helps with team alignment.

• How to create and manage subtasks within an issue for detailed tracking of smaller work items.

In this lesson, you’ll learn:

• The difference between hierarchical links (Epics → Issues → Subtasks) and issue-to-issue links (like “blocks” or “duplicates”).

• How hierarchy works only within a single project, and how it’s more flexible in company-managed projects.

• Why team-managed projects are limited in cross-project linking and portfolio visibility.

• How to create linked issues using relationship types like blocks, is blocked by, duplicates, and relates to.

• When and why to use these links for tracking dependencies between tasks across different projects.

In this lesson, you’ll learn:

• What boards represent in Jira and how they visualize issues from one or more projects.

• The difference between Scrum and Kanban boards, and when to use each.

• How to create new boards—including filtering issues using basic or advanced options.

• How board views like backlog and active sprints (Scrum) or Kanban backlog (Kanban) help organize workflow.

• Why boards do not own issues, and how updating an issue in one board reflects across all others.

In this lesson, you’ll learn:

• A recap of Jira’s core structure: instance → projects → boards → issues.

• How company-managed and team-managed projects differ in navigation and capabilities.

• How to find and manage projects, boards, issues, and key features using the global navigation menu and search bar.

• How to interpret issue hierarchy (Epics → Stories/Tasks → Subtasks) and use breadcrumbs to navigate between them.

• Tips for quickly accessing your backlog, switching board views, and troubleshooting missing content.

In this lesson, you’ll learn:

• What Scrum is and how it fits into the Agile framework, including sprints, standups, reviews, and retrospectives.

• How to prepare your backlog by organizing and prioritizing issues using epics and simple drag-and-drop.

• How to create and start a sprint, define a sprint goal, and set start/end dates.

• How to move issues through the sprint workflow (To Do → In Progress → Done).

• What to do when a sprint ends—how to complete a sprint, manage incomplete items, and start planning the next.

In this lesson, you’ll learn:

• Why Agile teams use story points instead of hours for estimating work—focusing on size, complexity, and uncertainty.

• How to apply the Fibonacci-based scale (1, 2, 3, 5, 8, 13, 20) to estimate user stories in Jira.

• How Jira automatically displays total story points for each sprint and tracks sprint progress in real time.

• How to use progress bars in the Epic panel to visualize estimated vs. completed work.

• A look at time-based estimates and time tracking—how they work, when to use them, and why they’re generally not recommended in Agile.

In this lesson, you’ll learn:

• The purpose of a daily standup in Scrum and how to facilitate it using Jira.

• Traditional techniques like filtering issues by assignee, epic, or issue type to structure updates.

• How to use quick filters, labels, and the Swimlanes feature to group work visually by person or epic.

• A walkthrough of Jira’s newer tools:

  • “Start Standup” timer to manage speaker time.

  • Sprint insights panel showing real-time progress and a burndown chart.

• Tips to ensure your standup helps resolve blockers and keep the team aligned.

In this lesson, you’ll learn:

• What Kanban is and how it differs from Scrum—focusing on continuous flow rather than time-boxed iterations.

• How to manage work in Jira’s Kanban board using columns like To Do, In Progress, and Done.

• How to enable and use a Kanban backlog, and why it’s useful for prioritizing work outside the main board view.

• How to filter and organize issues using epics, assignees, labels, and swimlanes—just like in Scrum boards.

• How to configure your board layout, including whether epics show up as cards or in an epic panel.

In this lesson, you’ll learn:

• The importance of work visualization and how it supports continuous delivery in Kanban.

• How to configure your Kanban board layout, including:

  • Adding/removing columns,

  • Mapping statuses to columns,

  • Enabling the epic panel,

  • Customizing swimlanes and card layouts.

• How to set and use WIP (Work in Progress) limits to reduce bottlenecks and speed up delivery.

• What happens when issues disappear due to unmapped statuses—and how to prevent it.

• How to highlight key work (e.g., blocked items) using labels, colors, and custom filters in swimlanes.

In this lesson, you’ll learn:

• What the Cumulative Flow Diagram (CFD) is and how it helps track flow efficiency in Kanban.

• How to access and configure the CFD via the Reports tab on your Kanban board.

• How to interpret the chart:

  • Color-coded bands represent issue statuses over time.

  • Widening bands may indicate bottlenecks or work piling up.

• Why a stable, gradually rising diagram is ideal—and what it means when things look off.

• How to use this report to spot stagnation, identify workflow issues, and improve team throughput.

In this lesson, you’ll learn:

• How to create and apply labels to Jira issues, and why it's important to standardize label usage across your team.

• How labels can help group issues by themes like wishlist items, OKRs, or cross-epic initiatives.

• How to turn labels into Quick Filters and display them directly on your board for improved visibility.

• The role of the priority field in Jira—what it does, and why drag-and-drop sorting is often a better method for backlog prioritization.

• How to build Quick Filters based on priority levels to spotlight high-priority issues without disrupting backlog order.

In this lesson, you’ll learn:

• What components are in Jira and how they differ from labels.

• How to access and create components via the Project Settings panel.

• How to assign issues to one or multiple components and optionally set default assignees for each component.

• The benefits of components over labels:

  • Controlled by project admins (less risk of inconsistency).

  • Project-specific, making them ideal for internal structuring.

• How to use components with Quick Filters for better backlog and board visibility.

In this lesson, you’ll learn:

• What versions are in Jira (also called fixed versions or release versions) and how they’re used in software development.

• How to create and assign versions to issues directly from the issue view or through the Versions panel.

• How to visualize version progress using:

  • The version panel in the backlog,

  • The card layout customization to show assigned versions,

  • The Project Settings → Versions page for progress tracking and release management.

• How to release a version, reassign unfinished issues, and generate basic release notes.

• How versions complement other organizational tools:

  • Epics organize by functionality.

  • Versions track delivery timelines.

  • Components group by platforms or subsystems.

In this lesson, you’ll learn:

• Why Jira doesn’t have a built-in “template” feature—and how to work around it using cloning.

• How to create a reusable issue template with a structured description or subtasks (e.g., for sprint planning).

• How to label your templates (e.g., with a "template" tag) to easily filter and avoid editing the original.

• How to clone an issue with subtasks to quickly create structured checklists for recurring work.

• When to use tasks vs. stories, and how to assign cloned checklists to different team members for execution.

In this lesson, you’ll learn:

• How to access and use basic filters in Jira to search for issues by project, assignee, status, and other common fields.

• The difference between basic filters and JQL (Jira Query Language)—and how you can start with basic filters and convert them into JQL.

• How to filter for specific conditions like:

  • Issues not in a certain project,

  • Issues assigned to a user,

  • Issues with a specific story point estimate.

• How to convert filter results into Quick Filters for your board, using the JQL format.

• Why JQL offers more flexibility and how it enhances visibility and focus during team workflows.

In this lesson, you’ll learn:

• How to use basic filters more powerfully by combining fields like project, issue type, assignee, and status.

• How to perform bulk actions using filters:

  • Change issue status in bulk (e.g., transition to "Open"),

  • Clear labels, components, or versions across multiple issues,

  • Edit or move issues efficiently.

• How to customize list views by selecting which fields (e.g., labels, components) to display.

• How to save filters, name them clearly, and control access and editing permissions (e.g., private vs. organization-wide).

• How to export filtered issues to Excel/CSV and what to watch out for when re-importing them into Jira.

In this lesson, you’ll learn:

• The basic JQL structure: field → operator → value.

• How to reference Jira fields (e.g., assignee, issueType, story points) and combine conditions.

• Common operators used in JQL:

  • = / != for exact matches,

  • IS EMPTY / IS NOT EMPTY for checking field presence,

  • IN / NOT IN for multiple values,

  • > / < / >= / <= for numeric comparisons.

• How to use OR to combine conditions (e.g., issues unassigned OR assigned to others).

• Why using ORDER BY rank ASC is a best practice—for keeping consistent backlog order across boards.

• How to troubleshoot and improve query accuracy using dropdown suggestions and syntax awareness.

In this lesson, you’ll learn:

• The key date-related fields in Jira:

  • created, updated, due, resolved, and resolution.

• How to write time-based JQL queries using operators like:

  • >= (greater than or equal),

  • <= (less than or equal),

  • IS EMPTY (for unresolved or undated items).

• How to define time ranges using:

  • Relative time (e.g., -7d, -2w, +3d),

  • Keywords like startOfWeek, endOfMonth, startOfMonth, endOfWeek, etc.

• How to filter:

  • Issues created or updated within specific past or future timeframes,

  • Items due after a certain date or overdue.

• When and how to use ORDER BY rank ASC for consistent board ordering.

In this lesson, you’ll learn how to:

• Use the parent and parentEpic fields to query parent-child relationships:

  • Filter all children of a specific issue: parent = SP-44

  • Combine multiple parents with IN: parent IN (SP-44, SP-37)

  • Filter issues under a specific Epic using Epic Link (legacy) or parent = EPIC-KEY

• Use the issueLinkType and linkedIssues() functions to query linked issues:

  • Filter by link type: issueLinkType = "blocks" or "clones"

  • Query issues linked to a specific key:
    issue in linkedIssues("SP-9")

  • Filter by both issue key and link type:
    issue in linkedIssues("SP-9", "is blocked by")

• Understand how directionality matters in issue links:

  • "blocks" vs. "is blocked by" yield different results based on the issue perspective.

  • Use links to understand blockers, clones, dependencies, and related work.

• Combine link-based queries with other filters like issueType, status, or custom fields using AND / OR logic.

In this lesson, you’ll learn how to:

• Start with natural language: Before writing your query, describe what you need in plain English. For example: “All my tasks created this week that aren’t done yet.”

• Combine filters with logic: Use AND to combine multiple conditions (e.g. assignee = currentUser() AND status != Done AND created >= -7d). Use OR to include alternatives.

• Use saved filters as building blocks: Create reusable filters like summary ~ "points" and then build on them using filter = "contains points" in new queries.

• Always add sorting: Stick to ORDER BY Rank ASC to keep boards consistent and predictable—especially helpful when viewing or using filters across multiple boards.

• Use the cheat sheet! A JQL Cheat Sheet (or similar) is linked in resources to help remember syntax and operators like ~ (contains), IN, IS EMPTY, and more.

In this lesson, you’ll learn:

• How to customize board settings like name, admins, and filters

• How to configure estimation method, WIP limits, card layout, and swimlanes

• The importance of mapping all statuses to board columns to avoid hidden issues

• Key differences between Scrum and Kanban board settings (e.g., sub-filters, completed issue visibility)

• Useful features like card coloring, "days in column" indicators, and quick filters for board management

In this lesson, you’ll learn:

• What Jira workflows are and how they’re made of statuses and transitions

• How to view a workflow and understand which statuses are available from each state

• Why some transitions are limited, customized, or require specific conditions

• How Jira categorizes statuses as “to do,” “in progress,” or “done” for reporting and progress tracking

• The difference between a status and a resolution—and how resolutions help clarify why work was completed or stopped

In this lesson, you’ll learn:

• What workflows are and how they define issue status transitions in Jira

• How to create and customize a workflow with statuses, transitions, and screens

• The role of post functions, conditions, and resolution screens in workflow transitions

• How workflows can impact what users see and do—and why complexity should be introduced gradually

• Why understanding workflows helps users troubleshoot and work more effectively, even without admin access

In this lesson, you’ll learn:

• How to approach coordination between multiple Jira teams working on a shared product

• The importance of shared visibility, transparency, and alignment across boards

• Common challenges when collaborating across projects with different workflows

• What questions to consider before deciding on boards, filters, or dashboards

• Why balancing autonomy with collaboration is key to successful cross-team work

In this lesson, you’ll learn:

• How to track a shared release across multiple Jira projects using JQL

• Best practices for filtering by components, labels, and fix versions

• How to combine multiple queries using OR and parentheses for clarity

• When and how to create a dedicated release board for cross-team visibility

• Tips for maintaining alignment when managing shared scope across teams and workflows

In this lesson, you’ll learn:

• How to use the timeline (formerly roadmap) feature to visualize work in sprints

• The difference between scheduling by sprint dates vs. start/due dates

• How to identify dependencies and plan across multiple sprints

• Best practices for avoiding waterfall-style overplanning in Agile

• Tips for managing timelines effectively—even without Jira Premium

In this lesson, you’ll learn:

• What to check when issues “disappear” from a shared board

• How mismatched workflows across projects can cause unmapped statuses

• How to remap statuses in the board layout settings

• Why statusCategory = "In Progress" is better than listing exact statuses

• How to build reliable cross-project queries regardless of individual workflows

In this lesson, you’ll learn:

• The purpose of dashboards and how they replace manual reporting

• How to create a personal or shared Jira dashboard from scratch

• Ways to customize layout and add/edit gadgets

• How to use filters to control gadget content

• Tips for setting refresh settings and sharing your dashboard with others

In this lesson, you’ll learn:

• How to build a dashboard useful for multi-project tracking

• Commonly used gadgets: filter results, issue statistics, pie chart, and 2D filter statistics

• Tips for optimizing layout and real estate usage

• How to use filters and stats to monitor statuses, assignees, and workload

• Why interactive gadgets help you explore queries and learn JQL on the go

In this lesson, you’ll learn:

• How to rename, share, and manage permissions for your Jira dashboard

• Options for refreshing dashboard data manually or automatically

• How to copy dashboards for reuse or customization

• What a wallboard view is and when it might be useful

• How to configure and rotate multiple dashboards for display purposes

In this lesson, you’ll learn:

• How reports differ from dashboards in Jira

• How to use key Scrum reports: burndown, sprint report, and velocity chart

• What to look for during sprint reviews, including scope changes and incomplete work

• How to interpret epic reports to track progress and estimation accuracy

• Which Jira reports are most useful for Scrum teams and why

In this lesson, you’ll learn:

• What the Control chart shows and how it helps monitor cycle time

• Why reducing cycle time and keeping it stable improves delivery speed

• How to interpret the red average line and the blue variation area

• What issue clusters and outliers reveal about your process

• How to refine report accuracy using filters and column settings in Kanban boards

In this lesson, you’ll learn:

• What types of automation rules can be created as a project admin (non-global)

• How to build a rule triggered when an issue is assigned

• How to use smart values to personalize automated emails

• When and how to add conditions (e.g., using JQL) to refine your automation logic

• Common pitfalls and tips for introducing automation responsibly in a team setting

In this lesson, you’ll learn:

• How to find, install, and configure the Smart Checklist app in Jira

• What Smart Checklist is and how it enhances issue tracking

• How to apply and customize checklist templates like Definition of Done

• Why checklists can be a cleaner alternative to subtasks

• How to reuse checklists and integrate them with Jira automation

In this lesson, you’ll learn:

• How to automate reopening an issue when a comment is added to a completed item

• How to detect status and trigger workflows using conditions and transitions

• How to auto-apply labels based on keywords in issue summaries or descriptions

• Practical examples of lightweight automation to streamline team workflows

In this lesson, you’ll learn:

• What global automation is and how it differs from project-level automation

• How to prepare detailed requests for your Jira admin to set up global rules

• How to use templates to automate tasks across multiple projects

• A step-by-step example: auto-close child issues when the epic is closed

• Why clear communication is key when applying rules that affect other teams

In this lesson, you’ll learn:

• Handy Jira keyboard shortcuts for faster navigation and task updates

• How to bulk select, reorder, and edit multiple issues efficiently

• Tips for managing long backlogs with ST/SB shortcuts

• How to use list view to quickly update issue fields like in a spreadsheet

• Why mastering these tricks can save time in your daily Jira use

In this lesson, you’ll learn:

• Best practices for writing clear, concise Jira issue summaries and descriptions

• How to maintain clean boards with proper statuses, labels, and components

• The importance of accountability and collaboration in Jira usage

• How to avoid common pitfalls with labels and notification overload

• Tips for using watchers, comments, and history to stay aligned as a team

In this lesson, you’ll learn:

• What to do when an issue “disappears” from your board

• How to troubleshoot common causes: filters, status mapping, and JQL

• Why unmapped statuses and hidden components can hide issues

• How to restore missing issues by updating board filters and columns

• Extra tips for Kanban boards with sub-filters and date limits

In this lesson, you’ll learn:

• How to apply your Jira skills by creating a complete sample project

• Tips for setting up boards, filters, and issue types from scratch

• Creative ways to use Jira for personal or team projects

• Ideas for practicing with real-life or fun example projects

• Why continued hands-on use is key to mastering Jira

In this lesson, you’ll learn:

• How to apply everything you’ve learned in real Jira projects.

• Ways to improve your team’s collaboration using Jira features.

• Why small changes—like better use of labels—can make a big impact.

• How to keep practicing and sharpening your skills after the course.

• Where to go next if you want to explore Jira admin or Agile topics.