Hands-On Jira for Scrum Kanban Agile Delivery | Zero to Hero

In this video we'll learn what Jira is and how it's meant to be used.

1. Understand what Jira is and its core purpose

2. Learn how Jira supports Agile project management

3. Explore key use cases across teams and industries

4. Identify how Jira helps in planning, tracking, and delivery

5. Understand different Jira project types and frameworks

6. Learn how teams collaborate using Jira

7. Get familiar with basic Jira components and structure

8. Build a foundation for using Jira effectively

This video helps to provide you with steps on setting jira on cloud.

Lecture Description: Setting Up Jira Software Cloud

This session provides a comprehensive, step-by-step walkthrough for administrators and project leads looking to establish a robust foundation in Jira Cloud. We move beyond the basics to ensure your instance is configured for both immediate use and long-term scalability.

Key Learning Objectives

• Account Initialization: Navigating the Atlassian Cloud signup process and selecting the right Jira product tier (Free, Standard, or Premium) for your team's needs.

• Site Setup & Naming: Establishing your unique site URL and configuring global settings, including time zones and language defaults.

• User Management: * Inviting team members via email.

  • Defining Product Access and administrative roles.

  • Organizing users into Groups for streamlined permission handling.

• Project Creation Framework: * Choosing between Team-managed (flexible, decentralized) and Company-managed (standardized, complex) project types.

  • Selecting the appropriate template (Scrum, Kanban, or Bug Tracking) based on your team's workflow.

• Workflow & Issue Customization: * Understanding the lifecycle of a task (To Do, In Progress, Done).

  • Introduction to custom fields and screen schemes to capture essential data points.

• Integration Basics: Connecting your Jira instance with other essential tools like Confluence or Slack to centralize communication.

Note: This lecture is designed for beginners. No prior experience with Atlassian products is required, though a basic understanding of your team's project management style is recommended.

let us do an hands-on exercise using sample data project.

Lecture Description: Hands-On Practice with Sample Data

Theory meets practice in this interactive session. Instead of starting with a blank slate, we will use a pre-populated sample project to simulate a real-world working environment. This allows you to experiment with Jira’s features without the fear of "breaking" a live production site.

Interactive Exercise Breakdown

• Project Import & Generation: * Using built-in Jira templates to generate a "Sample Data" project.

  • Understanding how sample data populates the Backlog and Board views instantly.

• Backlog Grooming Simulation: * Practicing the "Drag and Drop" mechanics to prioritize user stories.

  • Estimating effort using Story Points or original time estimates.

• Sprint Management: * Creating your first Sprint and moving issues from the Backlog into the active iteration.

  • Defining Sprint goals and clicking "Start Sprint" to initiate the countdown.

• Active Board Navigation: * Transitioning issues across the Kanban or Scrum board.

  • Using Quick Filters to find specific tasks assigned to you or marked as high priority.

• Issue Anatomy Exploration: * Adding comments, attachments, and @mentioning teammates within sample tickets.

  • Linking related issues (e.g., "blocks" or "is duplicated by") to see dependency mapping in action.

• Reporting & Analytics: * Generating a Burndown Chart based on your simulated sprint activity.

  • Analyzing the Velocity Chart to understand team capacity and performance trends.

Hands-On Goal: By the end of this exercise, you will have the confidence to manage a live project by having already navigated the most common daily "traps" in a safe, controlled environment.

In this video, we will explore various versions of Jira.

Lecture Description: Exploring the Jira Product Family

Jira is not a "one-size-fits-all" tool. In this session, we break down the different versions and deployments of Jira to help you identify which flavor best aligns with your team’s specific goals, workflows, and industry requirements.

Key Learning Objectives

• The Three Core Pillars:

  • Jira Software: The flagship version designed for agile teams, featuring robust support for Scrum, Kanban, and software development integrations.

  • Jira Service Management (JSM): Optimized for IT and operations teams, focusing on service desks, incident management, and customer requests.

  • Jira Product Discovery: Exploring the newest addition tailored for product managers to prioritize ideas and build roadmaps before they hit the development backlog.

• Specialized Use Cases:

  • Jira Work Management: How business teams (Marketing, HR, Legal) use Jira with simplified views like Calendars, Timelines, and Forms.

• Deployment Options: Cloud vs. Data Center:

  • Jira Cloud: Understanding the benefits of Atlassian-hosted environments, including automatic updates and rapid feature deployment.

  • Jira Data Center: A look at self-managed, enterprise-grade environments designed for high availability and strict regulatory compliance.

• The Ecosystem Approach:

  • How different versions of Jira "talk" to one another to create a seamless flow of information across an entire organization.

  • The role of the Atlassian Marketplace in extending the functionality of any Jira version.

• Choosing Your Path:

  • A comparative analysis of feature sets, pricing models, and administrative overhead for each version.

Summary: By the end of this video, you will be able to confidently navigate the Atlassian catalog and select the specific Jira product that scales with your team's complexity.

Refresh your agile knowledge and learn about traditional project management technique.

Lecture Description: Agile vs. Traditional Project Management

This session serves as a foundational bridge between two worlds. Whether you are a seasoned practitioner needing a refresher or a newcomer navigating different methodologies, we will compare the iterative nature of Agile with the structured predictability of Traditional (Waterfall) project management.

Key Learning Objectives

• Defining the Waterfall Methodology:

  • Understanding the linear, sequential phases: Requirements → Design → Implementation → Verification → Maintenance.

  • Identifying the strengths of Waterfall, such as clear milestones and predictable budgeting for fixed-scope projects.

• Agile Core Principles Refresher:

  • Revisiting the Agile Manifesto: Prioritizing individuals and interactions over processes and tools.

  • The iterative cycle: How "Plan-Do-Check-Act" allows for continuous improvement and rapid pivots.

• A Side-by-Side Comparison:

  • Flexibility vs. Rigidity: Comparing how each methodology handles changes in requirements mid-project.

  • Customer Involvement: Contrast the "big bang" delivery of Waterfall with the frequent, incremental releases of Agile.

  • Risk Management: Analyzing how Agile uncovers risks earlier through constant testing and feedback loops.

• Choosing the Right Approach:

  • Factors that influence your choice: Project size, team expertise, industry regulations, and clarity of the end goal.

  • Recognizing "Hybrid" models: When and why organizations combine elements of both to balance structure with speed.

• The Role of Jira in Both Worlds:

  • A brief look at how Jira supports both traditional Gantt-style planning (via Timelines) and Agile ceremonies (via Boards and Backlogs).

Lecture Goal: You will gain the perspective needed to choose the most effective "tool for the job," ensuring you aren't just following a process, but actually delivering the best results for your specific environment.

Refresher course on agile methodology.

Lecture Description: Agile Methodology Refresher

In this session, we strip away the jargon to refocus on the core values and mechanics that make Agile successful. This "back-to-basics" deep dive is designed to align your team on the why behind the rituals, ensuring your processes remain lean, purposeful, and results-oriented.

Key Learning Objectives

• The Four Values of the Manifesto:

  • Re-centering on the fundamental shifts: Why we value Responding to Change over following a rigid plan.

  • Moving from "Contract Negotiation" to Customer Collaboration.

• Core Agile Principles in Practice:

  • Sustainable Development: How to maintain a constant pace indefinitely without burnout.

  • Simplicity: The art of maximizing the amount of work not done.

• The Anatomy of an Iteration:

  • A breakdown of the feedback loop: How Sprints or Cycles turn raw ideas into "Done" increments.

  • Understanding the importance of the Definition of Done (DoD) to ensure consistent quality.

• Agile Roles & Accountabilities:

  • Clarifying the distinct responsibilities of the Product Owner, the Scrum Master/Facilitator, and the Development Team.

  • How self-organizing teams differ from traditional "command and control" structures.

• Ceremony Optimization:

  • Daily Stand-ups: Keeping them focused on blockers and synchronization, not just status reporting.

  • Retrospectives: Techniques for turning honest feedback into actionable improvements for the next cycle.

• Measuring What Matters:

  • Moving beyond vanity metrics to focus on Outcome-based goals.

  • Introduction to flow metrics and lead time as indicators of team health.

Lecture Goal: Whether you've been practicing for years or are just getting started, this refresher ensures you aren't just "doing" Agile, but actually being Agile—staying flexible enough to deliver high value in a changing market.

Learn Scrum in around 5 minutes.

Lecture Description: Scrum in 5 Minutes

This high-impact, "crash course" session is designed to give you a clear, functional understanding of the Scrum framework in the time it takes to grab a coffee. We focus on the essential structure that allows teams to deliver complex products with speed and quality.

Key Learning Objectives

• Scrum in a Nutshell:

  • Defining Scrum as a lightweight framework for solving complex adaptive problems.

  • The "Three Pillars" of Empiricism: Transparency, Inspection, and Adaptation.

• The Three Essential Roles:

  • Product Owner: The "Value Maximizer" who manages the Backlog.

  • Scrum Master: The "Coach" who removes blockers and ensures the team follows the process.

  • Developers: The "Creators" who do the hands-on work to deliver the Increment.

• The Artifacts (The "Stuff" We Use):

  • Product Backlog: The master list of everything needed in the product.

  • Sprint Backlog: The specific tasks selected for the current cycle.

  • Increment: The usable, "Done" piece of work delivered at the end of a Sprint.

• The Five Events (The "Meetings"):

  • The Sprint: The 1–4 week heartbeat where the work happens.

  • Sprint Planning: Setting the goal and choosing the work.

  • Daily Scrum: A 15-minute sync to stay on track.

  • Sprint Review: Inspecting the outcome and gathering stakeholder feedback.

  • Sprint Retrospective: Inspecting the process and identifying one "win" for the next Sprint.

• The Scrum Lifecycle:

  • A visual walkthrough of how a requirement travels from the Backlog to a finished feature.

Lecture Goal: To strip away the complexity and provide you with a mental "cheat sheet" of Scrum, enabling you to participate in any Scrum team with immediate confidence.

Focus on knowing the differences between Agile and Scrum.

Lecture Description: Agile vs. Scrum – Understanding the Difference

A common point of confusion for many is using the terms "Agile" and "Scrum" interchangeably. In this session, we clarify the relationship between the two, helping you understand how a broad philosophy (Agile) translates into a specific, actionable framework (Scrum).

Key Learning Objectives

• The "Umbrella" Concept:

  • Visualizing Agile as the overarching philosophy or mindset guided by the Agile Manifesto.

  • Defining Scrum as one of several specific frameworks (like Kanban or XP) used to implement that Agile mindset.

• Philosophy vs. Process:

  • Agile is the "What": A set of values focusing on iterative development, customer feedback, and flexibility.

  • Scrum is the "How": A structured set of "rules" involving specific roles (Scrum Master), events (Sprints), and artifacts (Backlogs).

• Key Structural Differences:

  • Flexibility: Agile is a general approach that can be adapted widely; Scrum is more prescriptive with its specific ceremonies and time-boxed iterations.

  • Leadership: Agile encourages self-organizing teams; Scrum specifically defines accountabilities to ensure the framework functions correctly.

• Comparing Delivery Styles:

  • How Agile focuses on the continuous delivery of value.

  • How Scrum breaks that delivery down into manageable "Sprints" to ensure regular inspection and adaptation.

• When to Use Which Term:

  • Learning how to speak accurately to stakeholders: When are you discussing "Agile Transformation" vs. "Scrum Implementation"?

  • Identifying if your team is truly "Doing Scrum" or simply following general "Agile" practices.

Lecture Goal: By the end of this video, you will be able to explain the "Rectangle vs. Square" relationship of Agile and Scrum, ensuring you use the right terminology and choose the right structural approach for your team's workflow.

Learn Kanban and how it differs from Agile.

Lecture Description: Kanban Fundamentals & The Agile Connection

While Scrum relies on structured time-boxes, Kanban focuses on the continuous flow of work. This session explores the principles of Kanban, how it fits under the Agile umbrella, and why it is the preferred choice for teams prioritizing flexibility and speed.

Key Learning Objectives

• Defining Kanban:

  • Understanding Kanban as a visual system for managing work as it moves through a process.

  • The core philosophy: "Stop Starting, Start Finishing."

• The Relationship to Agile:

  • Identifying Kanban as a specific framework under the Agile philosophy.

  • How Kanban fulfills Agile values through transparency, rapid delivery, and evolutionary change rather than revolution.

• The Four Core Principles of Kanban:

  1. Visualize the Workflow: Using a Kanban board to make invisible work visible.

  2. Limit Work in Progress (WIP): The "Secret Sauce"—preventing bottlenecks by restricting how many tasks can be in a specific stage at once.

  3. Manage Flow: Monitoring how work moves through the system to identify and clear blockers.

  4. Continuous Improvement (Kaizen): Using data and team feedback to evolve the process over time.

• Kanban vs. General Agile:

  • Structure: Unlike broader Agile concepts, Kanban does not require specific roles or fixed-length iterations (Sprints).

  • Cadence: Moving from "Batch" delivery to Continuous Delivery.

• Key Metrics in Kanban:

  • Cycle Time: How long it takes for a single task to go from "In Progress" to "Done."

  • Lead Time: The total time from when a request is made until it is delivered to the customer.

• When to Choose Kanban:

  • Identifying the best scenarios for Kanban, such as support teams, DevOps, or high-volume creative production.

Lecture Goal: You will gain a practical understanding of how to use visual cues and WIP limits to create a "pull system" that reduces stress and increases the speed of delivery for your team.

Lecture Description: Agile Project Management & The Iron Triangle

In this lecture, we shift from technical setup to the strategic core of project management. We explore the Iron Triangle (also known as the Triple Constraint) and how Agile methodologies redefine the relationship between scope, time, and cost to deliver higher value.

Key Learning Objectives

• The Foundation of Constraints:

  • Defining the three pillars: Scope (Features/Requirements), Schedule (Time), and Resources (Cost/Budget).

  • Understanding the "Trade-off" principle: Why changing one side of the triangle inevitably impacts the others.

• Traditional vs. Agile Triangles:

  • The Waterfall Approach: Analyzing the "Fixed Scope" model where time and cost are estimated to fit a rigid set of requirements.

  • The Agile Inversion: Discovering how Agile fixes Time and Cost (via Sprints and stable teams) while keeping Scope flexible to adapt to feedback.

• Managing Quality:

  • Identifying Quality as the central element that suffers when the triangle is pushed beyond its limits.

  • Strategies for maintaining high standards without "cutting corners" under pressure.

• The Concept of "Fixed vs. Variable":

  • Learning how to identify which constraints are immovable in your specific organizational context.

  • How to communicate these constraints effectively to stakeholders to manage expectations.

• Value-Driven Delivery:

  • Moving beyond "on time and on budget" to measure success by the Value delivered to the end user.

  • Prioritizing the "Right" scope over the "Full" scope to maximize ROI within existing constraints.

Key Takeaway: You will walk away with a mental framework for making tough project decisions, ensuring that when pressure mounts, you can defend the integrity of your project's quality and timeline.

In this video we'll learn about some of the key terms Jira uses and what they mean.

Lecture Description: Mastering Jira’s Core Vocabulary

To use Jira effectively, you first need to speak its language. This session is dedicated to decoding the fundamental building blocks of the platform, ensuring you understand the relationship between different data layers and how they organize your daily work.

Key Learning Objectives

• The Hierarchy of Organization:

  • Understanding the high-level containers that house your team's work and how they differ from one another.

  • Learning how Jira groups related items to provide a structured view of a product or department.

• The Anatomy of a "Work Unit":

  • Breaking down the individual entries that track tasks, bugs, or stories.

  • Exploring how these units hold data, attachments, and history to act as a "single source of truth."

• Categorization & Metadata:

  • Distinguishing between the labels and attributes used to filter, sort, and search for information quickly.

  • How specific fields allow for better reporting and project tracking.

• The Path of Progress:

  • Defining the underlying logic that dictates how a task moves from "New" to "Complete."

  • Understanding the rules and transitions that govern the lifecycle of your team's activities.

• Visualizing the Work:

  • Introduction to the different interfaces used to view your data, whether you are planning for the future or managing the present.

  • How different views highlight different aspects of the project’s health.

Lecture Goal: By the end of this video, you will have a solid grasp of the terminology required to navigate Jira's interface with ease and communicate clearly with your project stakeholders.

In this video we'll hop into Jira and get familiar with how the interface is organized.

Lecture Description: Navigating the Jira Interface

It’s time to move from theory to the screen. In this session, we take a guided "grand tour" of the Jira UI to ensure you feel at home within the platform. We focus on the layout and navigation patterns that will become the backbone of your daily workflow.

Key Learning Objectives

• The Global Navigation Bar:

  • Mastering the "Top Rail" to quickly jump between projects, filters, dashboards, and integrated apps.

  • Using the "Create" button—the universal starting point for any new task or requirement.

• The Project Sidebar:

  • Understanding the contextual menu that changes based on where you are in the system.

  • Learning how to toggle between different views like the Backlog, Board, and Timeline.

• Search & Discovery Tools:

  • Utilizing the Quick Search functionality to find specific tickets or pages in seconds.

  • A first look at how to save "Starred" or "Recent" items to create a personalized, efficient workspace.

• Workspace Personalization:

  • Navigating your User Profile settings to manage notifications and UI preferences (like Dark Mode).

  • Exploring the Jira Home concept to see a high-level summary of your assigned work.

• The Issue Detail View:

  • Understanding the layout of an individual ticket: where to find descriptions, activity feeds, and transition buttons without getting lost in the data.

• Contextual Help & Settings:

  • Locating the "Cog" icon for administration and the help menus for on-the-fly troubleshooting.

Lecture Goal: This video aims to remove the "blank screen" anxiety. By the end of this tour, you will know exactly where to click to find your work, update your teammates, and move your project forward.

In this video we'll learn the difference between the two different types of projects in Jira.

Lecture Description: Comparing Team-Managed vs. Company-Managed Projects

One of the most critical decisions you make in Jira happens at the very beginning: choosing your project type. This session breaks down the two distinct architectures available in Jira Cloud, helping you decide which model provides the right balance of autonomy and control for your team.

Key Learning Objectives

• The Philosophical Difference:

  • Team-Managed Projects: Understanding the "bottom-up" approach designed for independent teams who want full control over their own configuration.

  • Company-Managed Projects: Exploring the "top-down" approach built for organizations that require standardized processes across multiple teams.

• Configuration & Permissions:

  • Comparing who can make changes: Individual team leads (Team-Managed) versus centralized Jira Administrators (Company-Managed).

  • How each type handles custom fields, issue types, and workflow transitions.

• Scalability and Consistency:

  • Analyzing the benefits of Shared Schemes: Why Company-Managed projects are essential for cross-project reporting and enterprise-wide consistency.

  • Understanding the "Sandbox" nature of Team-Managed projects and how they protect the rest of the organization from accidental configuration changes.

• Feature Availability:

  • Identifying specific features (like advanced permissions or complex workflow properties) that are exclusive to Company-Managed projects.

  • Recognizing the simplified, user-friendly interface unique to the Team-Managed experience.

• Decision Framework:

  • When to choose Team-Managed: Best for small teams, pilots, or projects with unique workflows that don't need to align with other departments.

  • When to choose Company-Managed: Best for large-scale software organizations, PMOs, and teams requiring strict governance.

Lecture Goal: By the end of this video, you will be able to evaluate your team's needs against Jira’s project structures, ensuring you don't outgrow your setup six months down the line.

Learn different types of projects in JIRA.

Since the previous lecture covered the theory of choosing between different Jira project types, this activity is designed to put those decision-making skills to the test. You will play the role of a Jira Consultant advising different departments on which project blueprint fits their unique needs.

Activity: The "Right Fit" Project Challenge

In this exercise, you will evaluate three distinct team scenarios and determine the optimal Jira project configuration for each. This will help you practice aligning business requirements with Jira’s functional capabilities.

Activity Steps

• Scenario Analysis:

  • Team A (The Mobile App Devs): A team of 10 engineers working in 2-week iterations. They need to track "Done" work against a release version and manage a complex backlog.

  • Team B (The HR Department): A non-technical team tracking candidate interviews and onboarding. They prefer a calendar view and simple "To Do" lists without complex agile terminology.

  • Team C (The IT Help Desk): A support team that needs to track "Time to Respond" and provide a portal where employees can submit tickets for broken laptops.

• The Decision Matrix:

  • For each team, select the Project Category (Software, Service Management, or Work Management).

  • Select the Project Template (Scrum, Kanban, or Task Tracking).

  • Decide between Team-managed or Company-managed based on whether the team needs total autonomy or must follow company-wide security standards.

• Validation Check:

  • Identify one "Trade-off" for each decision (e.g., "Choosing Team-managed here means they lose access to shared cross-project schemes").

Activity Goal: By the end of this exercise, you will move beyond clicking "Next" on the setup screen and start making intentional architectural choices that save your team hours of reconfiguration later.

In this video we will understand key difference between a Jira Project and Jira Board.

********NOW JIRA PROJECTS ARE REPLACED WITH JIRA SPACES***************

Lecture Description: Jira Projects vs. Jira Boards

One of the most common hurdles for new users is distinguishing between where data is stored and how it is visualized. This session clarifies the relationship between Projects and Boards, ensuring you understand how to organize your work versus how to manage your daily tasks.

Key Learning Objectives

• The "Container" vs. The "Lens":

  • Defining a Project as the underlying database or "bucket" where issues, permissions, and settings live.

  • Defining a Board as a visual interface—a "lens" that displays specific issues from one or more projects.

• The One-to-Many Relationship:

  • Understanding how a single Jira Project can power multiple boards (e.g., a "Development Board" for engineers and a "Roadmap Board" for stakeholders).

  • Exploring how a single board can pull data from multiple projects simultaneously to create a cross-functional view.

• Structural Differences:

  • Project Level: Where you define "who" has access, "what" types of tasks exist (Bugs vs. Stories), and "how" the workflow is structured.

  • Board Level: Where you define "how" the work is viewed (Scrum vs. Kanban), how columns are mapped, and which filters are applied to hide or show data.

• Ownership and Permissions:

  • Distinguishing between Project Administrators (who manage the settings) and Board Administrators (who manage the visual layout and filters).

  • How changing an issue’s status on a board directly updates the data within the underlying project.

• Common Use Cases:

  • Using boards to create "Personal Views" of work assigned to you across several different company projects.

  • Setting up specific boards for different team rituals, such as a "Triage Board" for new bugs and a "Sprint Board" for active development.

Lecture Goal: By the end of this video, you will stop viewing Projects and Boards as the same thing. You'll gain the flexibility to build custom views that show exactly what you need to see, without moving or duplicating your data.

In this video we'll learn how to create a new team-managed project.

• Understand what a team-managed project is and when to use it

• Navigate to the project creation screen in Jira

• Select the appropriate project template (Scrum/Kanban)

• Configure basic project details (name, key, access)

• Set project permissions and access levels

• Customize issue types and fields for the team

• Create and configure the project board

• Validate project setup and start adding initial work items

In this video we'll learn how to navigate around a team-managed project. Our first look at projects and navigating within a project.

1. Get an overview of the team-managed project interface

2. Identify key sections like backlog, board, reports, and settings

3. Navigate between project views efficiently

4. Understand the layout of issues and work items

5. Explore the project sidebar and quick access options

6. Learn how to open, view, and update issues

7. Use search and filters within the project

8. Build confidence navigating daily tasks within the project

In this video, we will understand Issues, Issue Hierarchy and Issue Fields. Any team member may find the need to create issues, whether you're in QA and found a bug or even a Developer creating a ticket to be worked on.

1. Understand what issues are and their role in Jira

2. Explore different issue types (story, task, bug, etc.)

3. Learn issue hierarchy (epic → story/task → sub-task)

4. Identify key issue fields and their purpose

5. Create issues for bugs, tasks, or enhancements

6. Update fields like status, priority, assignee, and labels

7. Link issues to reflect dependencies and relationships

8. Follow best practices for clear, actionable issue creation

In this video we'll learn how to create new issues in a team-managed project. Any team member may find the need to create issues, whether you're in QA and found a bug or even a Developer creating a ticket to be worked on.

1. Learn how to create new issues in a team-managed project

2. Choose the appropriate issue type (story, task, bug)

3. Enter clear summaries and detailed descriptions

4. Fill key fields like priority, assignee, and due date

5. Attach files, links, and supporting information

6. Follow best practices for writing actionable tickets

7. Create issues from backlog, board, or quick add options

8. Ensure issues are ready for team review and execution

In this video we'll learn about some of the customization options we have for team-managed projects.

1. Explore customization options available in team-managed projects

2. Modify issue types to suit team needs

3. Add, edit, or remove custom fields

4. Configure workflows and status transitions

5. Customize board columns and backlog structure

6. Set permissions and access controls

7. Adjust notifications and project settings

8. Tailor the project setup for optimal team productivity

Learn about workflows and how to manage issues from creation to done.

Lecture Description: Understanding Workflows & The Issue Lifecycle

Every task in Jira follows a specific path from the moment it is conceived to the moment it is finished. In this session, we dive into the "engine room" of Jira—the Workflow. You will learn how to guide work through various stages while maintaining process integrity and visibility.

Key Learning Objectives

• Defining the Workflow:

  • Understanding a workflow as the digital representation of your team’s real-world process.

  • Identifying the three core components: Statuses (the "where"), Transitions (the "how"), and Resolutions (the "why").

• The Anatomy of an Issue Lifecycle:

  • Creation: What happens when a ticket is first born and the importance of the "Open" or "To Do" state.

  • Active Progress: Managing the transition into "In Progress" and how to signal that work is actually happening.

  • Review & Verification: Implementing intermediate steps like "In Review" or "QA" to ensure quality before completion.

  • The "Done" State: Understanding the critical difference between a status being "Closed" and a resolution being "Fixed" or "Completed."

• Visualizing the Path:

  • How to view the Workflow Diagram directly within a Jira ticket to see where a task can go next.

  • Recognizing "Simplified" vs. "Complex" workflows and how they impact team flexibility.

• Transition Rules & Best Practices:

  • Understanding Triggers and Conditions: How Jira can automate movements or restrict who can move a ticket to the next stage.

  • Using Post-Functions: What happens behind the scenes (like updating a field or sending an email) when a status changes.

• Bottleneck Identification:

  • Using the workflow to spot where work gets "stuck" (e.g., tickets piling up in the "Review" column).

  • How a well-defined workflow provides the data needed for accurate cycle time and lead time reporting.

Lecture Goal: By the end of this video, you will understand how to move work through Jira with purpose, ensuring that every status update provides meaningful information to the rest of your team.

A look at the backlog view of an agile scrum board.

Lecture Description: Navigating the Scrum Backlog

The Backlog is the engine room of any Scrum project. In this session, we step away from the active board to explore the planning space where ideas are refined, prioritized, and prepared for development. You will learn how to transform a messy list of requirements into a structured roadmap for your team.

Key Learning Objectives

• Anatomy of the Backlog View:

  • Identifying the two primary sections: The Product Backlog (the master list) and the Sprint Planning area.

  • Understanding the "Rank" system: How to use simple drag-and-drop mechanics to establish a single source of truth for priority.

• The "Issue Detail" Fly-out:

  • How to view and edit ticket details without leaving the backlog screen to keep your planning flow uninterrupted.

• Sprint Creation and Organization:

  • Learning how to create "Sprint Buckets" and move high-priority items from the product backlog into an upcoming iteration.

  • Understanding the Sprint Footer—monitoring your team’s total Story Point estimate against your known capacity.

• Version and Epic Panels:

  • Utilizing the side panels to organize work into high-level themes (Epics) or specific release cycles (Versions).

  • Using these panels as "Quick Filters" to slice your backlog by specific goals or features.

• Refinement & Estimation:

  • Where to input Story Points or time estimates directly within the backlog view.

  • Recognizing the visual indicators for "Unestimated" work that needs the team's attention during grooming.

• Backlog Health Indicators:

  • Understanding the "Waterline": How to visualize what is likely to be completed in the next cycle versus what stays in the hopper.

Lecture Goal: By the end of this video, you will be able to efficiently organize hundreds of tasks into a clear, actionable plan, ensuring your team always knows exactly what the most important "next thing" is.

As a member of an agile team using Jira, an essential function would be to search for issues through the issue navigator. This lecture goes through basic filters and searching capabilities on Jira.

Lecture Description: Mastering the Issue Navigator & Basic Search

Finding the right information at the right time is a core skill for any Jira user. This session focuses on the Issue Navigator, teaching you how to slice through hundreds of tasks to find exactly what you need using Jira’s built-in search tools and basic filtering logic.

Key Learning Objectives

• The Issue Navigator Overview:

  • Accessing the central hub for all project data and understanding the difference between the List view and Detail view.

  • Learning how to customize your view by adding, removing, or reordering columns to show the metadata most relevant to you.

• Basic Search Functionality:

  • Using the Text Search bar to find keywords within summaries, descriptions, and comments.

  • Understanding the "Contextual Search" that automatically suggests issues based on your recent activity.

• Filtering by Core Attributes:

  • Mastering the drop-down filters to quickly narrow down results by:

    • Project: Searching across one or multiple teams.

    • Issue Type: Isolating Bugs, Stories, or Tasks.

    • Status: Seeing only what is "In Progress" or "Blocked."

    • Assignee: Finding work assigned to you, your team, or unassigned items.

• Saving & Sharing Filters:

  • How to save your most frequent searches as "Starred Filters" for one-click access in the future.

  • Sharing filter results with teammates to ensure everyone is looking at the same "slice" of data during meetings.

• Exporting Data:

  • A brief look at how to take your search results out of Jira and into formats like CSV or Excel for external reporting or stakeholder updates.

• The Bridge to Advanced Search:

  • Understanding when "Basic" filtering reaches its limit and identifying the entry point for JQL (Jira Query Language).

Lecture Goal: By the end of this video, you will no longer feel "lost" in Jira. You will have the tools to pull custom lists of work in seconds, turning a massive database into a personalized and manageable task list.

We'll add another lecture and one-up it by searching using JQL. The video shows how you can switch between basic and advanced searches, and how basic searches let you learn about how you form your advanced search queries.

Lecture Description: Advanced Searching with JQL

Ready to unlock the full power of Jira's data engine? This session moves beyond simple dropdown menus and introduces you to JQL (Jira Query Language). You will learn how to write precise queries to find exactly what you need, and more importantly, how to use Jira’s "Basic" mode as a training ground to master advanced searching.

Key Learning Objectives

• The JQL Foundation:

  • Understanding the anatomy of a query: Field + Operator + Value (e.g., priority = High).

  • How JQL allows for complex logic that basic filters can't handle, such as "OR" statements and "NOT" exclusions.

• The "Switch" Technique:

  • Learning how to toggle between Basic and Advanced search modes.

  • Pro Tip: Using the Basic interface to set up a search and then switching to JQL to see how Jira "writes" the code—the fastest way to learn JQL syntax.

• Smart Auto-Complete:

  • Utilizing Jira’s built-in syntax helper that suggests fields and values as you type, preventing errors and speeding up your workflow.

• Dynamic Date Searching:

  • Moving beyond static dates to find work based on relative time (e.g., created > -7d to find everything created in the last week).

  • Searching for work that missed its mark, such as duedate < now() AND status != Done.

• Functions and Keywords:

  • Introduction to powerful functions like membersOf() to search for entire teams or currentUser() to create dynamic filters that work for whoever is logged in.

• Troubleshooting Your Syntax:

  • Identifying the "Red X" vs. the "Green Check": How Jira provides real-time feedback on whether your query is valid.

Lecture Goal: By the end of this video, you will transition from a casual user to a "Power User." You'll have the ability to build sophisticated, reusable filters that can power custom dashboards and complex project reports.

This lecture shows you how you can save your frequent searches, in order to be more efficient when using Jira and searching for issues.

Lecture Description: Efficiency with Saved Filters

Searching is only half the battle; the real efficiency comes from never having to write the same query twice. This session focuses on the "Save" and "Manage" side of the Jira Issue Navigator, teaching you how to turn your most important searches into persistent, one-click shortcuts.

Key Learning Objectives

• The Art of Saving:

  • How to transform a complex JQL query or a set of basic filters into a Saved Filter.

  • Naming conventions: Best practices for naming filters so they remain recognizable in a long list (e.g., "My Blocked Tasks - Mobile Project").

• Accessing Your Shortcuts:

  • Utilizing the "Filters" dropdown in the global navigation bar to quickly jump to your most-used views.

  • Managing your "Starred" filters to keep your high-priority data at the top of your interface.

• Collaboration & Permissions:

  • Understanding the difference between Private and Shared filters.

  • How to share a filter with a specific Project, a Group, or the entire organization so your team is "singing from the same sheet of music."

• The "Source of Truth" for Dashboards:

  • Learning why saved filters are the fundamental building blocks for Jira Dashboards and Gadgets.

  • How updating a single saved filter automatically updates every chart or list that relies on it.

• Subscription & Automation:

  • Setting up Filter Subscriptions: How to have Jira email you (or your team) the results of a filter on a daily or weekly schedule (e.g., a "Monday Morning Bug Report").

• Maintaining Your Filter Library:

  • How to edit, rename, or delete obsolete filters to keep your workspace clean and relevant.

Lecture Goal: This video is about reclaiming your time. By the end of this session, you will have a personalized toolkit of filters that allows you to monitor your project's pulse without manually filtering data every time you log in.

Dashboards provide a cool way to view different kinds of data within Jira, so we'll spend some time creating a custom dashboard that would display different kinds of information.

Lecture Description: Building Custom Jira Dashboards

Information is only valuable if it’s visible. In this session, we move from searching for data to visualizing it. You will learn how to transform your saved filters into a dynamic, real-time Dashboard that provides a "command center" view of your project’s health and your team's progress.

Key Learning Objectives

• The Dashboard Concept:

  • Understanding the Dashboard as a customizable workspace that aggregates information from across Jira into a single screen.

  • Distinguishing between System Dashboards (default) and Custom Dashboards (personalized).

• Creating Your Canvas:

  • Step-by-step instructions on creating a new dashboard from scratch.

  • Selecting the right Layout: Choosing between one, two, or three-column structures to organize your information effectively.

• Introduction to Gadgets:

  • Understanding Gadgets as the individual "widgets" or charts that display your data.

  • Exploring the Gadget Directory: How to find and add tools like Pie Charts, Created vs. Resolved charts, and "Assigned to Me" lists.

• Powering Gadgets with Filters:

  • The critical link: Learning how to point a gadget toward a Saved Filter to populate it with specific data.

  • Configuring gadget settings to adjust refresh rates, colors, and display limits.

• Designing for Your Audience:

  • The Team Dashboard: Focus on active sprint progress, blockers, and high-priority bugs.

  • The Stakeholder Dashboard: Focus on high-level roadmaps, epic progress, and overall project status.

  • The Personal Dashboard: Focus on "My Tasks," recent activity, and watched issues.

• Sharing and Governance:

  • How to manage viewing and editing permissions so your team can benefit from the dashboard you’ve built.

  • Copying existing dashboards to use as templates for new projects.

Lecture Goal: By the end of this video, you will be able to build a professional, automated reporting page. You’ll spend less time manually digging for updates and more time acting on the insights your custom dashboard provides.

We will look at setting up a Wallboard which can be projected or displayed on a big monitor for the whole team to monitor or track important metrics relevant to the team.

Lecture Description: Setting Up a Jira Wallboard

A Dashboard is for your desk, but a Wallboard is for the room. In this session, we explore how to take your Jira data and project it onto a big screen to create a "Shared Information Radiator." You will learn how to configure high-visibility metrics that keep the entire team aligned and motivated without anyone needing to log in or click a mouse.

Key Learning Objectives

• The Concept of the "Information Radiator":

  • Understanding why passive visibility of data changes team behavior and increases accountability.

  • Identifying the difference between a standard interactive Dashboard and a high-contrast, automated Wallboard.

• Configuring for High Visibility:

  • How to enable Wallboard Mode to remove UI clutter like navigation bars and sidebars.

  • Designing with the "10-foot rule": Choosing Gadgets that are readable from across the room.

• The Wallboard Slideshow:

  • Setting up a Dashboard Slideshow to automatically cycle through multiple dashboard pages.

  • Adjusting transition timings to ensure the team has enough time to digest each "slide" of data.

• Selecting the Right Metrics for Display:

  • Sprint Progress: Visualizing the Burn-down chart to see if the team is on track for the "Done" goal.

  • Blocker Alerts: Using high-visibility gadgets to highlight critical bugs or stalled tickets.

  • Team Velocity & Health: Displaying cumulative flow or "Days remaining in Sprint" to create a sense of shared urgency.

• Hardware & Setup Best Practices:

  • Tips for projecting or displaying Jira on TV monitors using Chromecasts, dedicated PCs, or smart TV browsers.

  • How to manage "Auto-Refresh" settings so the data on the wall stays current without manual intervention.

• Security & Accessibility:

  • Managing permissions so the Wallboard can be viewed on a shared screen while keeping sensitive project data secure.

Lecture Goal: By the end of this video, you will be able to transform your team's workspace into a data-driven environment. You’ll learn how to build a visual "heartbeat" for your project that celebrates progress and flags risks the moment they appear.

As a project owner or Scrum Master, this would be one of the main responsibilities when managing an agile team and ensuring the agile boards are configured in a manner that maximizes productivity within the team. We will look at every single configurable aspect of agile boards, both Scrum and Kanban.

Lecture Description: Advanced Board Configuration for Success

As a Scrum Master or Product Owner, the Agile board is your primary tool for steering the ship. This deep dive moves beyond the default settings to explore every lever you can pull to optimize team flow. You will learn how to architect a board that doesn't just "track work," but actively identifies bottlenecks and drives team productivity.

Key Learning Objectives

• Column Management & Workflow Mapping:

  • How to map multiple workflow statuses to a single board column to simplify the team's view.

  • Strategies for adding "Buffer" columns (like Ready for Review) to visualize wait times and handoffs.

• Mastering WIP Limits (Kanban Focus):

  • Setting Minimum and Maximum constraints on columns to prevent multitasking and surface hidden bottlenecks.

  • Understanding "Visual Warnings": How the board signals when a team has taken on too much work.

• Swimlanes: Adding Horizontal Logic:

  • Organizing your board into horizontal rows to prioritize work by Expedites, Assignees, Stories, or Epics.

  • How to use "Query-based Swimlanes" to highlight specific risks (e.g., tickets that haven't moved in 5 days).

• Card Layout & Customization:

  • Tailoring the "look" of a card: Adding up to three extra fields (like Due Date or Component) so the team can see vital info without clicking into the ticket.

  • Using Card Colors to provide instant visual cues for high-priority bugs, specific labels, or different work types.

• Quick Filters: The Power of One-Click Views:

  • Creating and naming custom filters that appear at the top of the board (e.g., "Only My Tasks" or "Blockers").

  • Using JQL to build filters that help the team focus during Daily Stand-ups.

• Estimation and Time Tracking:

  • Configuring the "Estimation Statistic" (Story Points vs. Original Estimate) and determining how the board calculates progress.

  • Setting the Burndown Chart source to ensure your reporting is accurate and meaningful.

• Board Permissions & Sub-filters:

  • Managing who can change the board’s configuration to prevent "accidental" process changes.

  • Using Board Sub-filters to keep the board clean by hiding completed or irrelevant work after a certain timeframe.

Lecture Goal: By the end of this session, you will possess the technical expertise to turn a standard Jira board into a precision-engineered productivity tool. You will know how to configure your workspace to make the right way to work the easiest way to work.

As a project owner or Scrum Master, this would be one of the main responsibilities when managing an agile team and ensuring the agile boards are configured in a manner that maximizes productivity within the team. We will look at every single configurable aspect of agile boards, both Scrum and Kanban.

Lecture Description: Advanced Board Configuration for Success

As a Scrum Master or Product Owner, the Agile board is your primary tool for steering the ship. This deep dive moves beyond the default settings to explore every lever you can pull to optimize team flow. You will learn how to architect a board that doesn't just "track work," but actively identifies bottlenecks and drives team productivity.

Key Learning Objectives

• Column Management & Workflow Mapping:

  • How to map multiple workflow statuses to a single board column to simplify the team's view.

  • Strategies for adding "Buffer" columns (like Ready for Review) to visualize wait times and handoffs.

• Mastering WIP Limits (Kanban Focus):

  • Setting Minimum and Maximum constraints on columns to prevent multitasking and surface hidden bottlenecks.

  • Understanding "Visual Warnings": How the board signals when a team has taken on too much work.

• Swimlanes: Adding Horizontal Logic:

  • Organizing your board into horizontal rows to prioritize work by Expedites, Assignees, Stories, or Epics.

  • How to use "Query-based Swimlanes" to highlight specific risks (e.g., tickets that haven't moved in 5 days).

• Card Layout & Customization:

  • Tailoring the "look" of a card: Adding up to three extra fields (like Due Date or Component) so the team can see vital info without clicking into the ticket.

  • Using Card Colors to provide instant visual cues for high-priority bugs, specific labels, or different work types.

• Quick Filters: The Power of One-Click Views:

  • Creating and naming custom filters that appear at the top of the board (e.g., "Only My Tasks" or "Blockers").

  • Using JQL to build filters that help the team focus during Daily Stand-ups.

• Estimation and Time Tracking:

  • Configuring the "Estimation Statistic" (Story Points vs. Original Estimate) and determining how the board calculates progress.

  • Setting the Burndown Chart source to ensure your reporting is accurate and meaningful.

• Board Permissions & Sub-filters:

  • Managing who can change the board’s configuration to prevent "accidental" process changes.

  • Using Board Sub-filters to keep the board clean by hiding completed or irrelevant work after a certain timeframe.

Lecture Goal: By the end of this session, you will possess the technical expertise to turn a standard Jira board into a precision-engineered productivity tool. You will know how to configure your workspace to make the right way to work the easiest way to work.

In this video, let us use Teams feature to build a collaborative team.

Lecture Description: Building Collaborative Teams in Jira

Individual work is only part of the equation; true efficiency comes from how your team interacts as a unit. In this session, we explore the Teams feature in Jira—a powerful way to group users, manage shared availability, and streamline mentions. You will learn how to move beyond managing individual "users" and start managing high-performing, collaborative squads.

Key Learning Objectives

• Defining "Teams" in the Atlassian Ecosystem:

  • Understanding the difference between a Jira Group (used for permissions) and a Team (used for collaboration and visibility).

  • How Teams act as a centralized identity that follows you across Jira, Confluence, and Atlas.

• Creating and Configuring Your Team:

  • Step-by-step guide to creating a team, adding members, and assigning a team lead.

  • Personalizing your Team Profile: Adding a description, mission statement, and a team avatar to build a shared identity.

• Streamlining Collaboration:

  • Using Team Mentions: Learning how to tag an entire team (e.g., @Product-Design) in comments or descriptions to notify everyone simultaneously.

  • Viewing the Team Home: Accessing a dedicated space that shows what the team is working on, their recent activity, and their core members.

• Connecting Teams to Work:

  • Utilizing the Team Field: How to associate specific issues or epics with a team rather than just an individual.

  • Understanding how this field powers advanced cross-team reporting and capacity planning.

• External Integration:

  • Exploring how Jira Teams can sync with external tools like Slack or Microsoft Teams to bridge the gap between project management and daily communication.

Practical Takeaways

• For Scrum Masters: Use Teams to quickly filter boards and dashboards by squad rather than manual lists of names.

• For Product Managers: Use Team mentions to loop in the right group of stakeholders without forgetting a single contributor.

• For Team Members: Use the Team Home to get a pulse on what your direct colleagues are tackling this week.

Lecture Goal: By the end of this video, you will be able to assemble a digital version of your real-world team. This setup will reduce communication friction and ensure that the right people always have eyes on the right work.

In this video let us configure reports or Insights for the board. Helps to being a efficient team.

Lecture Description: Leveraging Board Insights & Agile Reports

Data-driven teams are successful teams. In this session, we explore the Reports and Insights features within Jira, moving beyond simple task tracking to deep analytical understanding. You will learn how to interpret the charts Jira generates automatically to identify bottlenecks, predict future performance, and lead more effective retrospective meetings.

Key Learning Objectives

• Understanding Board Insights:

  • Accessing the Insights panel directly from your active board to see real-time data on Sprint progress and workload distribution.

  • Identifying the "Status Health" metric to see if work is piling up in specific stages of your workflow.

• The Scrum Powerhouse: The Burndown Chart:

  • Learning how to read the "Ideal Burn" line vs. your team's actual progress.

  • Recognizing common patterns, such as "late-sprint spikes" or "plateaus," and what they reveal about your planning accuracy.

• Flow Analysis with the Cumulative Flow Diagram (CFD):

  • Using the CFD to visualize the stability of your process over time.

  • Identifying "widening bands" that signal bottlenecks and "narrowing bands" that suggest under-utilization.

• Predictability with the Velocity Chart:

  • Analyzing your team's historical performance to determine a realistic amount of work for future Sprints.

  • Understanding the difference between Commitment and Completed work to improve stakeholder expectations.

• Cycle Time and Lead Time:

  • Measuring how long it actually takes for an idea to go from "To Do" to "Done."

  • Using the Control Chart to identify outliers—those specific tickets that took significantly longer than average—and investigating why.

• Sharing Insights with Stakeholders:

  • How to export report data or include specific charts in your status updates to provide transparency on project health.

Retrospective Focus

• The "So What?" Factor: It’s not just about looking at a graph; it’s about asking, "Why does our chart look like this?"

• Continuous Improvement: Using these reports as the "Evidence" during your Sprint Retrospectives to suggest process changes.

Lecture Goal: By the end of this video, you will be able to translate Jira’s complex data into actionable leadership. You’ll stop guessing how the project is going and start using objective metrics to drive your team toward higher efficiency.

Once the project is set up, the next step would be to ensure that work is represented in the form of epics and stories.

Lecture Description: Structuring Work with Epics & Stories

A project is only as good as the work inside it. Now that your environment is configured, it’s time to build the hierarchy. In this session, we transition from high-level goals to actionable tasks by defining Epics and Stories. You will learn how to break down complex features into manageable pieces of value that your team can deliver.

Key Learning Objectives

• Understanding the Jira Hierarchy:

  • Epics: Defining the "Big Picture"—large bodies of work that can be broken down into smaller tasks and usually span multiple Sprints.

  • User Stories: Defining the "Value"—short, simple descriptions of a feature told from the perspective of the person who desires the new capability.

• Creating and Managing Epics:

  • How to create an Epic and assign it a unique color and name for easy tracking on the board.

  • Using the Epic Panel in the backlog to group related stories and monitor high-level progress.

• Writing Effective User Stories:

  • Mastering the standard format: "As a [user], I want [action], so that [benefit]."

  • Adding Acceptance Criteria to ensure the "Definition of Done" is clear for every ticket.

• Linking Stories to Epics:

  • The "Parent-Child" relationship: How to ensure every story contributes to a larger objective.

  • Visualizing the connection: Seeing Epic labels on your cards and in your backlog view.

• Organizing the Workload:

  • Using Epics to categorize your roadmap (e.g., "Mobile App Login," "Payment Integration," "User Profile").

  • How to "bulk move" existing issues into an Epic to clean up an unorganized backlog.

Best Practices for Product Owners

• The "Vertical Slice": Ensuring each Story delivers a functional piece of value rather than just a technical task.

• Epic Sizing: Learning when an Epic is "too big" (it never ends) or "too small" (it should have just been a Story).

• Visibility: Using the "Epic Progress Bar" in Jira to give stakeholders an instant status update without them having to ask.

Lecture Goal: By the end of this video, you will move away from a "flat list" of tasks. You will be able to build a structured, meaningful backlog that clearly shows how every small task contributes to your project's major milestones.

This lecture represents the stage where sprint planning meeting takes place, and the sprint backlog is created and the sprint started.

Lecture Description: Sprint Planning & Launching the Sprint

The planning meeting is the bridge between a well-groomed backlog and a high-performing team. In this session, we simulate the Sprint Planning ceremony. You will learn how to transition from a list of "things we could do" to a committed Sprint Backlog, culminating in the official "Start Sprint" button that kicks off your development cycle.

Key Learning Objectives

• The Planning Ceremony Workflow:

  • Identifying the two parts of planning: Defining the Sprint Goal (the "Why") and selecting the Sprint Backlog (the "What").

  • How to facilitate the move from the Product Backlog into an active Sprint container within Jira.

• Building the Sprint Backlog:

  • Using the drag-and-drop interface to move stories from the "bottom" to the "top" based on team capacity.

  • Understanding the role of Story Points during this phase to ensure the team isn't over-committed.

• Defining the Sprint Goal:

  • Utilizing the "Sprint Goal" field in Jira to provide a North Star for the team during the next two weeks.

  • How this goal appears on the Active Board to keep everyone focused on the primary objective.

• The "Start Sprint" Configuration:

  • A step-by-step walkthrough of the launch screen:

    • Sprint Name: Choosing a clear, chronological, or thematic name.

    • Duration: Setting standard 1, 2, or 4-week cadences.

    • Dates: Aligning the start and end dates with your team's actual work schedule.

• Capacity and Velocity Checks:

  • Using Jira's footer indicators to compare the current Sprint's total estimates against the team's historical average (Velocity).

  • Identifying "Scope Creep" before the sprint even starts.

Execution Checklist

• Check the "Top of Mind": Are the highest priority items at the very top of the list?

• Estimate Validation: Does every ticket in the Sprint have an estimate?

• Capacity Logic: If the team's average velocity is 30 points, are we trying to cram in 50? (Use this moment to negotiate scope).

Lecture Goal: By the end of this video, you will know how to turn a planning meeting into a concrete plan of action. You’ll gain the confidence to lead a team through the technical setup required to start a Sprint with a clear goal and a realistic workload.

This video shows you how you can manage your versions, to represent software releases. Remember that in scrum, a version is pre-planned and is released when the planned work is complete.

Lecture Description: Release Management with Versions

In the world of software development, work isn't just "done"—it's released. This session explores the Versions feature in Jira (often called the Release Hub), which allows you to group completed work into tangible software updates. You will learn how to plan, track, and ship versions that align with your product roadmap and Scrum milestones.

Key Learning Objectives

• The Concept of a Version:

  • Understanding a Version as a "container" for a set of features, fixes, and improvements intended for a specific release date.

  • Distinguishing between the Sprint (a time-box) and a Version (a functional milestone).

• Creating and Planning Releases:

  • Navigating to the Releases tab in your project sidebar.

  • Setting up a new version: Defining the Version Name (e.g., v1.0, "Spring Update"), Start Date, and Release Date.

• Mapping Work to a Release:

  • Using the "Fix Version" field on individual stories and bugs to associate them with a specific release.

  • Using the Versions Panel in the backlog to quickly "bulk-assign" tickets to a version via drag-and-drop.

• The Release Hub: Monitoring Progress:

  • Reading the Version Progress Bar: Understanding how much work is "To Do," "In Progress," and "Done" within a specific release.

  • Identifying "Release Risks": How Jira flags issues that are part of a version but aren't currently in a sprint or are falling behind schedule.

• The "Release" Action:

  • The technical steps to officially "Release" a version in Jira.

  • Managing unfinished work: What happens to tickets that aren't completed when it’s time to ship? (Moving them to the "Next Version" or back to the backlog).

• Automated Release Notes:

  • A look at how Jira can automatically generate a list of all issues included in a version, providing an instant summary for stakeholders and customers.

Scrum Strategy: Fixed Scope vs. Fixed Time

• The Scrum Philosophy: Remind the team that while Sprints are fixed-time, Versions in Scrum are often "Fixed-Scope"—the version is shipped once all the planned value is verified and ready.

• Version Integrity: Why you should avoid "leaking" unrelated work into a version to keep your release notes clean and focused.

Lecture Goal: By the end of this video, you will be able to manage the entire release lifecycle. You'll move beyond tracking daily tasks and start managing the actual delivery of software, ensuring your stakeholders know exactly what is shipping and when.

This lecture focus on how to create a release or version in JIRA for a Kanban type of project execution.

Lecture Description: Managing Releases in Kanban

In a Kanban environment, work flows continuously rather than in fixed-length sprints. This means "Releasing" happens differently—often on-demand or once a specific set of features is ready. This session focuses on how to use Jira’s Versions and Release functionality specifically for the Kanban framework, ensuring your continuous delivery remains organized and trackable.

Key Learning Objectives

• Kanban vs. Scrum Releases:

  • Understanding the shift from "Sprint-based" releases to Continuous Delivery or "Milestone-based" releases.

  • How to use Versions as logical checkpoints in a never-ending flow of work.

• The "Release" Button on the Kanban Board:

  • How to use the built-in "Release" feature directly from the Done column to clear the board and archive completed work.

  • Understanding the "Fix Version" requirement: How Jira prompts you to assign a version to all currently completed issues.

• Creating Versions for Continuous Flow:

  • Setting up versions in the Release Hub without strict start/end dates to accommodate a flexible delivery schedule.

  • Using the Fix Version field to "tag" work as it moves through the pipeline.

• The "Release Search" Workflow:

  • Using filters to identify all tickets that are in the "Done" status but haven't been assigned to a version yet.

• Tracking Progress in the Release Hub:

  • Monitoring the Kanban Release Page to see the volume of work completed over time.

  • Identifying "Scope Creep" in a Kanban context—when more work is being added to a version than is being finished.

• Archiving and Cleanup:

  • The importance of "Releasing" in Kanban to keep the board visually clean and performant.

  • How to view historical release data to report on team throughput over several months.

Kanban Best Practices

• Don't Wait Too Long: In Kanban, it is best practice to "Release" and clear your Done column frequently to keep the board manageable.

• Version as a Tag: Think of the Version in Kanban as a "Shipping Label"—it tells everyone which "truck" the task left the factory on.

Lecture Goal: By the end of this video, you will know how to manage software delivery in a continuous flow environment. You’ll be able to clear your Kanban board effectively while maintaining a perfect historical record of every update your team ships.

Lecture Description: Navigating the Automation Command Center

Before you can build powerful rules, you need to know where the tools are kept. In this session, we take a guided tour of the Automation Screen. We will move past the "magic" of automation and look at the actual interface where rules are built, managed, and audited. Understanding this layout is the first step toward becoming a Jira power user.

Key Learning Objectives

• The Rule Builder Interface:

  • The "If-This-Then-That" Sidebar: Understanding the visual flowchart that shows your triggers, conditions, and actions in a vertical sequence.

  • The Component Menu: How to navigate the library of available triggers (When), conditions (If), and actions (Then).

• The Rules Management List:

  • State and Status: Identifying which rules are Enabled (Active) vs. Disabled (Draft/Paused).

  • Scope Visibility: Distinguishing between Project-specific rules and Global rules that affect the entire Jira instance.

  • Owner and Attribution: Seeing who created the rule and who last modified it.

• The Audit Log (The "Black Box"):

  • Learning how to read the log to see exactly when a rule ran.

  • Status Codes: Understanding "Success," "No Actions Performed" (when conditions weren't met), and "Error" (when a rule fails).

  • Deep-diving into error messages to troubleshoot why an automation didn't behave as expected.

• Automation Usage & Limits:

  • Locating the usage gauge to see how many "Multi-project" or "Global" executions your plan has used for the month.

• Templates and Library:

  • Exploring the Template Library: Pre-built rules provided by Atlassian that you can "copy-paste" into your project to save time.

The Three Pillars of an Automation Rule

1. Triggers: The "When"—The event that kicks things off (e.g., a ticket is moved).

2. Conditions: The "If"—The filters that must be met for the rule to continue.

3. Actions: The "Then"—The actual task Jira performs (e.g., sending an email or changing a field).

Lecture Goal: By the end of this video, you will feel at home in the Automation workspace. You'll know exactly where to go to build a new rule, how to check if your existing rules are working correctly, and how to fix them if they aren't.

Lecture Description: Automating Communication with Comments

Automation in Jira isn't just about moving tickets; it’s about keeping people informed without manual effort. In this session, we explore one of the most useful "Simple Rules" in Jira Automation: Adding a Comment. You will learn how to trigger automated updates that provide context to stakeholders, alert assignees, or log internal notes exactly when they are needed.

Key Learning Objectives

• The Anatomy of the Rule:

  • Trigger: Identifying the event that starts the rule (e.g., Issue Transitioned, Field Value Changed, or Issue Created).

  • Action: Configuring the "Add Comment" component to execute the message.

• Smart Values in Comments:

  • Moving beyond static text: Learning how to use Smart Values like {{issue.reporter.displayName}} or {{now.format("dd/MMM/yy")}} to create personalized, dynamic comments.

  • Example: "Hi {{issue.reporter.firstName}}, this ticket has been moved to QA for testing."

• Common Use Cases for Automated Comments:

  • The Welcome Message: Automatically posting a comment when a ticket is created to let the reporter know the expected SLA.

  • The "Stalled" Alert: Posting a reminder if a ticket has been in "In Progress" for more than 3 days.

  • External Visibility: Using comments to notify stakeholders when a specific milestone (like an Epic completion) is reached.

• Internal vs. External Communication:

  • Configuring the comment visibility to ensure internal notes stay private while customer-facing updates are clear.

• Loop Prevention:

  • Understanding the importance of the "Check to prevent multiple triggers" setting to ensure your automation doesn't accidentally create an infinite loop of comments.

The "Why" Behind the Rule

• Reduce Manual Toil: Stop typing the same "Status Update" messages ten times a day.

• Standardize Information: Ensure that every ticket contains the same level of required information or "Next Steps" instructions.

• Audit Trail: Automatically log timestamps or specific data changes in the comment section for a clear historical record.

Lecture Goal: By the end of this video, you will be able to set up a "silent assistant" that handles routine communication for you. You’ll learn how to keep your team and stakeholders perfectly aligned through targeted, automated messaging.

Lecture Description: Targeted Automation—Filtering by Issue Type

Automation is most effective when it is surgical. While global rules are great, you often need to trigger actions only for specific types of work. In this session, we "one-up" our automation skills by learning how to use Conditions. We will build a rule that adds a comment only when a Bug is identified, ensuring that developers get specific instructions without cluttering up standard Stories or Tasks.

Key Learning Objectives

• The Power of the "If" Statement:

  • Understanding the Issue Fields Condition: How to tell Jira to check a specific attribute before proceeding with an action.

• Building the Rule Logic:

  • Trigger: Selecting the event (e.g., Issue Created).

  • Condition: Adding an "If" block where "Issue Type equals Bug."

  • Action: Adding a specific comment (e.g., "Please ensure you have attached logs and environment details for this bug report.").

• Context-Specific Messaging:

  • Why "Bug" automation is unique: Using comments to remind reporters of the Definition of a Bug or required reproduction steps.

• Cleaning Up Your Automation List:

  • Learning why scoped rules (like "Bugs only") are better for performance and organization than one giant rule with a dozen branches.

• Testing and Debugging:

  • Using the Automation Audit Log to see why a rule "skipped" a Story but "passed" a Bug.

Practical Use Case: The "Critical Bug" Alert

• The Logic: If a ticket is a Bug AND the priority is Highest, then add a comment tagging the On-Call Engineer.

• The Benefit: This ensures that high-priority defects get immediate eyes without the automation firing for every minor UI improvement or task.

Lecture Goal: By the end of this video, you will move from "global" automation to "conditional" automation. You’ll be able to create smart, type-specific workflows that provide the right information to the right people, only when it’s actually relevant.

Lecture Description: Tracking Evolution—Automating Field Changes

In a dynamic project, the nature of a task can change—a "Task" might turn into a "Bug," or a "Story" might be downgraded to a "Task." Keeping track of why these changes happen is vital for project integrity. In this session, we explore how to trigger automation based on Field Value Changes, specifically focusing on how to automatically document when an Issue Type is modified.

Key Learning Objectives

• The "Field Value Changed" Trigger:

  • Moving beyond "Creation" or "Transition" triggers to monitor specific data points.

  • Configuring the trigger to watch the Issue Type field specifically.

• Capturing the "From" and "To" States:

  • Using Smart Values to record exactly what changed.

  • Learning the syntax to pull the previous value: {{fieldChange.fromString}} and the new value: {{fieldChange.toString}}.

• Building the Audit Trail Comment:

  • Creating a professional, automated note: "Notice: Issue Type changed from {{fieldChange.fromString}} to {{fieldChange.toString}} by {{initiator.displayName}}."

• The "Change Management" Philosophy:

  • Why tracking issue type changes matters for reporting (e.g., ensuring a Story isn't turned into a Bug just to "fix" velocity metrics).

• Refining the Scope:

  • How to ensure the rule only runs on specific projects or under certain conditions (like only if the user is not an Administrator).

Practical Use Case: Preventing Confusion

• The Scenario: A developer starts working on a "Story," but realizes it's actually a "Bug" and changes it.

• The Problem: The QA team or Product Owner might lose track of why the requirements shifted mid-stream.

• The Solution: This automation forces a digital "paper trail," ensuring that anyone looking at the ticket history understands exactly when and how the scope of the work evolved.

Lecture Goal: By the end of this video, you will be able to build "Self-Documenting" issues. You’ll learn how to use automation to capture history in real-time, making your project easier to audit and your team's decisions more transparent.

Lecture Description: Mastering Auto-Assignment via Automation

Manual triage is one of the biggest time-wasters in project management. In this session, we look at the Auto-Assign rule—a simple yet transformative automation that ensures work never sits unowned in the backlog. You will learn how to build logic that automatically routes tickets to the right person based on specific triggers, ensuring immediate ownership and faster response times.

Key Learning Objectives

• The Logic of Auto-Assignment:

  • Moving away from the "Unassigned" default: Why auto-assignment is critical for team accountability.

• Building the Assignment Rule:

  • Trigger: Selecting the event (e.g., Issue Created or Issue Transitioned to "In Progress").

  • Action: "Assign Issue": Exploring the different ways to fill the "Assignee" field.

• Methods of Automation Assignment:

  • Specific User: Assigning every ticket of a certain type (like a Database Bug) to a specific subject matter expert.

  • User in a Group: Rotating assignments among a specific group of developers.

  • The "Initiator": Assigning the ticket to the person who triggered the rule (e.g., "Whoever moves this to In-Progress becomes the owner").

  • Balanced Workload (Round Robin): Introduction to more advanced logic where Jira distributes tickets evenly among team members to prevent burnout.

• Conditional Assignment:

  • Using Conditions to route work: If Component is "UI," assign to the Designer; if Component is "API," assign to the Backend Lead.

• The "User Property" Match:

  • How to assign a ticket based on a field value (e.g., assigning a ticket to the "Account Manager" listed on the customer profile).

Practical Use Cases

• The Support Desk: Automatically assigning all "High" priority tickets to the Team Lead.

• The "Claim" System: Setting an automation so that as soon as a ticket moves from the Backlog to "Selected for Development," it is assigned to the person who moved it.

• Cleaning up the "Unassigned" Bucket: Ensuring that no ticket ever stays unassigned for more than 24 hours.

Lecture Goal: By the end of this video, you will be able to eliminate the "Who is doing this?" bottleneck. You'll know how to set up rules that ensure every piece of work has a clear owner the moment it is ready to be tackled.

Lecture Description: Mastering Smart Values in Automation

If standard automation is the "body" of Jira, Smart Values are the "brain." In this session, we move beyond simple menus and learn how to use placeholders that allow you to access and manipulate virtually any data point within your project. You will learn how to build dynamic, "intelligent" rules that adapt their behavior based on the specific details of the issue they are processing.

Key Learning Objectives

• What are Smart Values?

  • Understanding the syntax: Learning how {{issue.summary}} or {{issue.key}} act as variables that Jira replaces with real data at runtime.

  • The power of the "dot" notation: Navigating the issue object (e.g., {{issue.fields.Reporter.displayName}}).

• Accessing People and Dates:

  • User Data: Pulling names, emails, or even time zones of the reporter, assignee, or the person who triggered the rule.

  • Date Manipulation: Using functions like {{now.plusDays(7)}} to automatically set due dates or {{issue.created.format("MMMM dd")}} for readable reporting.

• Advanced Text and Math Operations:

  • How to use smart values to perform basic calculations (e.g., adding two custom field values together).

  • String manipulation: Learning how to extract specific words from a summary or convert text to lowercase.

• The "Context" of the Rule:

  • Understanding the difference between the Trigger Issue ({{issue}}) and other related issues like Destination Issues or Parent Issues in complex multi-step rules.

• Debugging Smart Values:

  • Using the "Log Action" to print the value of a smart value to the Audit Log—a critical step for troubleshooting why a rule isn't behaving as expected.

"Smart" Use Case Examples

• Dynamic Notification: Sending a Slack message that says: "Hi {{assignee.firstName}}, the ticket {{issue.key}} was just prioritized by {{initiator.displayName}}."

• Automatic Task Syncing: If a sub-task is created, automatically prefixing its summary with the parent’s name: {{issue.parent.summary}} - [Sub-task].

• SLA Tracking: Commenting on a ticket with the exact time remaining before a deadline using date math.

Lecture Goal: By the end of this video, you will unlock the full potential of the Jira Automation engine. You’ll stop being limited by the dropdown menus and start writing custom logic that makes your workflows truly "smart" and responsive to your team's unique data.

Lecture Description: Debugging & Advanced Logic with Smart Values

The difference between a "working" rule and a "broken" one often comes down to what you can see behind the scenes. In this session, we deep-dive into the technical side of complex automation. You will learn how to pair Smart Values with the Audit Log to build, test, and troubleshoot sophisticated rules that handle complex data transformations.

Key Learning Objectives

• Advanced Smart Value Syntax:

  • Lists and Iteration: Learning how to pull data from multiple items (e.g., listing the summaries of all linked issues using {{lookupIssues.summary}}).

  • Conditional Logic within Values: Using the "if" function inside a smart value to display different text based on a field's state.

• The "Log Action" as a Debugging Tool:

  • Understanding why the Log Action is your best friend during development.

  • How to "print" a smart value to the Audit Log to verify its output before committing to a final action (like sending an email).

• Interpreting the Audit Log for Complex Rules:

  • Learning to read the "Payload" in the log to see exactly what data Jira received during the trigger.

  • Troubleshooting Branching Rules: How to use the log to track a rule as it moves from a Parent issue down to its Sub-tasks.

• Working with Change History:

  • Using smart values to compare what a value was versus what it is now to trigger logic only when a specific threshold is crossed.

• Sanitizing Data:

  • Using functions like {{issue.description.htmlSafe}} or {{issue.summary.jsonEncode}} to ensure your automated messages don't break when sent to external tools like Slack or Microsoft Teams.

The "Test-First" Workflow

1. Draft: Build your rule logic.

2. Log: Instead of the final action (like "Delete" or "Email"), use a Log Action to display the smart value you plan to use.

3. Run: Trigger the rule manually or with a test ticket.

4. Inspect: Check the Audit Log to ensure the value looks exactly as expected.

5. Finalize: Swap the Log Action for your intended final Action.

Lecture Goal: By the end of this video, you will move from "guessing" to "knowing." You’ll gain the technical confidence to build high-stakes automation rules, using the Audit Log to verify your logic every step of the way.

Lecture Description: On-Demand Automation—The Manual Trigger

Not every automation should happen automatically. Sometimes, you want the power of a complex workflow but only when a human decides the time is right. In this session, we explore the Manual Trigger. You will learn how to build "buttons" inside Jira that allow team members to execute sophisticated multi-step actions—like syncing to a sandbox or notifying a specific group—with a single click.

Key Learning Objectives

• Defining the Manual Trigger:

  • Understanding the "Action" menu: How manual rules appear as selectable options within a Jira ticket.

  • Use cases: When to use a manual trigger instead of an automatic one (e.g., "Ready for QA," "Escalate to Management," or "Generate Release Notes").

• Setting Up the Trigger:

  • Configuring the "Manual Trigger" component.

  • Group Restrictions: Learning how to limit who can see and run the button (e.g., only Scrum Masters or the "Developers" group).

• Prompting for Input (User Interaction):

  • Learning how to set up a "Prompt" that asks the user for information before the rule runs (e.g., asking for a "Reason for Escalation" or "Deployment Environment").

• Building Complex Downstream Actions:

  • Linking the manual trigger to multiple actions:

    1. Change the status of the ticket.

    2. Send a message to a specific Slack channel.

    3. Create a linked "Mirror" ticket in a different project.

• Visibility and UX:

  • How to name your rule clearly so the button is intuitive for your team.

  • Managing the "Success" and "Error" notifications that the user sees after clicking the button.

Why Use Manual Triggers?

• Human Oversight: Prevents automation from firing prematurely on tickets that aren't quite ready.

• Empowering the Team: Gives team members a "shortcut" for complex, repetitive administrative tasks.

• Process Control: Ensures that specific high-stakes actions (like "Close Sprint" or "Deploy to Production") are only initiated by authorized users.

Lecture Goal: By the end of this video, you will be able to create custom "shortcuts" within Jira. You’ll learn how to turn a 10-minute manual process into a 1-click automated rule, giving your team back their time while maintaining human control.

Lecture Description: Advanced Branching—Automating Sub-tasks

Note: This is an Advanced Topic. Before diving in, ensure you are comfortable with basic triggers and conditions, as branching introduces multi-layered logic that affects multiple issues simultaneously.

In standard automation, a rule usually stays on the ticket that triggered it. In this session, we break that boundary using Branching. You will learn how to "branch" a rule's execution so that an action taken on a parent issue—like a Story or Task—automatically flows down to its Sub-tasks. This is the key to maintaining perfectly synchronized work hierarchies.

Key Learning Objectives

• The Concept of a Rule "Branch":

  • Understanding the shift from a linear rule to a split path.

  • How branching allows you to perform actions on "Related Issues" rather than just the "Triggering Issue."

• Configuring the Sub-task Branch:

  • Identifying the "Branch Rule / Related Issues" component.

  • Selecting Sub-tasks as the branch type to ensure your actions only target the children of the current ticket.

• Synchronizing Statuses:

  • The "Auto-Close" Logic: Building a rule where, when a Story moves to "Done," all of its Sub-tasks are automatically moved to "Done" as well.

  • The "Blocker" Logic: Learning how to prevent a parent from closing if any of its sub-tasks are still open.

• Inheriting Data from Parents:

  • Using Smart Values within a branch to copy information from the parent to the sub-task (e.g., automatically updating the "Due Date" of all sub-tasks when the parent’s due date changes).

• Execution Flow and Limits:

  • Understanding that actions inside a branch run independently for each sub-task.

  • Monitoring the Audit Log to track how a single trigger can spark multiple successful actions across several different sub-task keys.

Advanced Use Cases

• Automated Cleanup: When a Story is "Cancelled," automatically add a comment to all sub-tasks and transition them to "Won't Do."

• Security & Permissions: Automatically assigning all sub-tasks to the same person who is assigned to the parent Story to ensure ownership continuity.

• Component Sync: Ensuring that if a Parent Story is tagged with the "UI" component, every sub-task created under it automatically inherits that same tag.

Lecture Goal: By the end of this video, you will have mastered the complexity of cross-issue automation. You will be able to build sophisticated workflows that keep your parent issues and sub-tasks in perfect harmony, eliminating the need for tedious manual updates across the issue hierarchy.

Lecture Description: Advanced Branching—All Created Work Items

Note: This is an Advanced Topic. This session covers complex automation flows that involve multiple actions across different tickets. We recommend completing the "Sub-tasks" branching lecture before starting this one.

In many workflows, one action needs to trigger a chain reaction of new tasks. But how do you control those new tasks once they are created? In this session, we explore the "All Created Issues" branch. You will learn how to trigger a rule, create one or more new work items, and then immediately perform actions—like assigning them or setting dates—on those newly created items within the same rule.

Key Learning Objectives

• The "Create vs. Branch" Challenge:

  • Understanding the limitation: A standard "Create Issue" action happens, but the rule normally stays focused on the trigger issue.

  • How the "All Created Issues" branch allows the rule to "follow" the newly born tickets to configure them further.

• Building a Multi-Stage Workflow:

  • The Trigger: (e.g., An Epic moves to "In Progress").

  • The Action: Creating multiple related Stories or Tasks.

  • The Branch: Using the "All Created Issues" block to act upon those new tickets specifically.

• Dynamic Configuration of New Items:

  • Using Smart Values inside the branch to pass data from the original trigger issue to the newly created ones.

  • Example: Setting the Due Date of all created tasks to {{triggerIssue.duedate.plusDays(14)}}.

• Cross-Project Automation:

  • How to use this branch to create a "Mirror" ticket in a different project and then immediately post a comment on that new ticket with instructions.

• Managing Multiple Creations:

  • Understanding how the branch handles "Bulk" creations—if your rule creates three tasks, the branch will execute its nested actions three times, once for each new item.

Advanced Use Cases

• Onboarding Checklists: When a "New Employee" ticket is created, use automation to create five sub-tasks (IT Setup, HR Paperwork, etc.) and automatically assign each one to a different department head.

• Definition of Ready: Automatically creating a "Documentation Task" every time a new "Feature Story" is moved to "Ready for Dev," ensuring the documentation is never forgotten.

• Standardized Testing: When a Bug is moved to "Fixed," automatically create a "Verification Task" for the QA team with a link back to the original bug.

Troubleshooting Tips

• The Audit Log: Because this rule touches multiple issues, the Audit Log becomes essential for tracking which "Created Issue" successfully received the branched actions.

• Loop Prevention: Ensuring that your "Created" issues don't accidentally trigger other rules that create even more issues, leading to an infinite automation loop.

Lecture Goal: By the end of this video, you will be able to orchestrate complex, multi-issue workflows. You'll move from simple one-to-one rules to one-to-many automations, ensuring that every new task generated by Jira is perfectly configured from the moment of its creation.

In this lecture we will connect Atlassian ROVO with CHATGPT.

The content is designed for project managers, scrum masters, product owners, team leads, and PMO professionals who want to understand how AI teammates can practically support their projects. It’s also suitable for business analysts, coordinators, and aspiring project leaders who are curious about leveraging AI to reduce manual overhead and improve visibility across their work. No prior experience with Rovo® or AI agents is required; a basic familiarity with project management concepts is enough to benefit from this lesson.

Lecture Description: Connecting Atlassian Rovo with ChatGPT

The future of project management isn't just about better software; it's about AI teammates that actively assist your workflow. In this session, we bridge the gap between your Atlassian ecosystem and the world’s most famous LLM. You will learn how to connect Atlassian Rovo with ChatGPT, creating a unified intelligence layer that understands your Jira projects, Confluence pages, and external knowledge bases.

Key Learning Objectives

• The Architecture of an AI Teammate:

  • Understanding how Rovo acts as the "connector" between your private company data and ChatGPT’s processing power.

  • Exploring the Rovo Agent framework: How these agents use ChatGPT to perform specialized tasks.

• Setting Up the Integration:

  • Navigating the Atlassian Administration settings to authorize the connection.

  • Ensuring security and data privacy: How Atlassian manages what information ChatGPT can "see" to keep your project data safe.

• Configuring ChatGPT as a Rovo "Knowledge Source":

  • Learning how to prompt ChatGPT through Rovo to summarize lengthy Confluence pages or draft Jira tickets based on conversation history.

  • Setting up "Custom Instructions" so your AI teammate understands your specific project management style (e.g., Agile, Waterfall, or Hybrid).

• Practical Use Cases for Leaders:

  • Automated Stakeholder Updates: Using the integration to draft weekly status reports by pulling data from Jira and having ChatGPT format it for executives.

  • Backlog Refinement: Asking the AI to identify missing acceptance criteria in user stories or suggest potential risks in a new Epic.

  • Instant Onboarding: How new team members can "ask" Rovo/ChatGPT questions about the project history and get answers instantly.

• Human-in-the-Loop Workflow:

  • Mastering the art of reviewing and refining AI-generated content before it is committed to your official project documentation.

Who Is This For?

• Project Managers & Scrum Masters: Reduce the "manual toil" of documentation and reporting.

• Product Owners: Use AI to help brainstorm features and refine the product backlog.

• Team Leads & PMO Professionals: Gain a bird's-eye view of project health through AI-driven summaries.

• Business Analysts: Quickly synthesize large amounts of project data into actionable insights.

Practical Takeaway

By the end of this lecture, you won't just see AI as a chatbot; you’ll see it as a functional member of your team. You will have the technical foundation to set up an AI agent that knows your project's history, understands your goals, and helps you navigate the daily complexities of project delivery.

Lecture Goal: To empower you with a "force multiplier" for your team. You will leave this session with a live connection between Atlassian Rovo and ChatGPT, ready to start automating the repetitive administrative tasks that currently slow your project down.

In this lecture, we will create and edit JIRA Issues from CHATGPT using Atlassian ROVO.

The content is designed for project managers, scrum masters, product owners, team leads, and PMO professionals who want to understand how AI teammates can practically support their projects. It’s also suitable for business analysts, coordinators, and aspiring project leaders who are curious about leveraging AI to reduce manual overhead and improve visibility across their work. No prior experience with Rovo® or AI agents is required; a basic familiarity with project management concepts is enough to benefit from this lesson.

Lecture Description: Creating & Editing Jira Issues via ChatGPT and Rovo

The power of Generative AI is no longer limited to just "writing text"—it can now take action. In this session, we explore the most practical application of Atlassian Rovo: the ability to create and modify Jira issues directly through a conversational interface. You will learn how to turn a simple chat with ChatGPT into structured, actionable work items in Jira, bypassing the need for manual data entry and complex forms.

Key Learning Objectives

• The Conversational Workflow:

  • Understanding how Rovo translates natural language (e.g., "Create a bug for the login issue") into a technical Jira issue creation.

  • Identifying the "Action" permissions required for Rovo to edit data in your Jira instance.

• Creating Issues from Scratch:

  • Mastering the prompt: Learning how to give the AI enough context (Summary, Description, Priority) to generate a complete ticket.

  • Automatically linking new issues to existing Epics or Sprints via chat commands.

• Editing Existing Issues:

  • Using ChatGPT to update fields: Learning how to say "Change the priority of JIRA-123 to High" or "Move the deadline for the landing page task to next Friday."

  • Appending information: Using AI to summarize a long chat and add it as a comment to a specific ticket.

• Context-Aware Creation:

  • Leveraging Rovo’s ability to "see" your Confluence pages to draft Jira Stories that perfectly match your project requirements.

  • How to ask the AI to "Refine this ticket" by adding missing acceptance criteria or technical details before it is saved.

• Safety and Review:

  • Understanding the "Draft" stage: How Rovo presents the proposed ticket for your approval before it officially enters the backlog.

  • Maintaining data integrity: Best practices for reviewing AI-generated tickets to ensure accuracy and alignment with team standards.

Who Is This For?

• Project Managers & Scrum Masters: Rapidly build out backlogs during planning sessions without manual typing.

• Product Owners: Transform brainstorming notes into fully-formed User Stories in seconds.

• Team Leads: Instantly update ticket statuses or priorities during stand-ups via mobile or web chat.

• PMO Professionals & Analysts: Streamline the "intake" process by having AI triage and create tickets based on stakeholder feedback.

Practical Takeaway

By the end of this lecture, you will be able to manage your Jira backlog through a fluid, natural conversation. You will reduce the time spent on "admin work" and increase the time spent on leadership and delivery, using AI to bridge the gap between your ideas and your project tracking software.

Lecture Goal: To turn your AI teammate into a functional project assistant. You will leave this session knowing how to command ChatGPT to build, organize, and update your Jira workload, making project management feel faster and more intuitive than ever before.

The content is designed for project managers, scrum masters, product owners, team leads, and PMO professionals who want to understand how AI teammates can practically support their projects. It’s also suitable for business analysts, coordinators, and aspiring project leaders who are curious about leveraging AI to reduce manual overhead and improve visibility across their work. No prior experience with Rovo® or AI agents is required; a basic familiarity with project management concepts is enough to benefit from this lesson.

Lecture Description: Transitioning Jira Issues via ChatGPT and Rovo

Moving work through a lifecycle is the heartbeat of any project, but manual status updates can often feel like a chore. In this session, we explore the "Action" capabilities of Atlassian Rovo by learning how to transition Jira issues using natural language. You will see how a simple command in ChatGPT can move a ticket from "To Do" to "In Progress," or "Done," allowing you to update your project board without ever leaving your conversation.

Key Learning Objectives

• The "Actionable AI" Workflow:

  • Understanding how Rovo maps natural language verbs (e.g., "start," "finish," "resolve") to your specific Jira workflow transitions.

  • Learning the "Trigger-Action" sequence: From asking the AI to seeing the live update in Jira.

• Executing Workflow Transitions:

  • Mastering the command syntax: How to say "Transition JIRA-456 to In Progress" or "Close out the bug related to the footer."

  • Handling multi-step transitions: How Rovo handles workflows with specific requirements or validators.

• Bulk Transitions via Chat:

  • Learning how to update multiple issues at once, such as "Move all my open tasks in the current sprint to 'In Progress'."

• Contextual Updates:

  • Using ChatGPT to provide the "Why": Automatically adding a resolution comment or a "Reason for Transition" as part of the automated move.

• Validation and Confirmation:

  • Understanding the confirmation loop: How Rovo ensures you intended to move the ticket before the change is finalized in the database.

Who Is This For?

• Project Managers & Scrum Masters: Keep the board updated in real-time during stand-ups or meetings through a simple chat interface.

• Product Owners: Quickly move approved stories from the backlog to "Ready" status during refinement sessions.

• Team Leads & PMO Professionals: Maintain high-level visibility and ensure "stale" tickets are moved to the correct status with minimal effort.

• Business Analysts & Coordinators: Update project health and task statuses while documenting requirements or meeting notes.

Practical Takeaway

By the end of this lecture, you will have mastered the ability to drive your project's flow through simple conversation. You will eliminate the friction of navigating between tabs and menus to update statuses, ensuring your Jira board always reflects the true state of work with zero manual overhead.

Lecture Goal: To bridge the gap between "talking about work" and "updating work." You will leave this session with the power to manage your Jira lifecycle through ChatGPT, making your workflow faster, more responsive, and incredibly efficient.

The content is designed for project managers, scrum masters, product owners, team leads, and PMO professionals who want to understand how AI teammates can practically support their projects. It’s also suitable for business analysts, coordinators, and aspiring project leaders who are curious about leveraging AI to reduce manual overhead and improve visibility across their work. No prior experience with Rovo® or AI agents is required; a basic familiarity with project management concepts is enough to benefit from this lesson.

Lecture Description: Sprint Health Check via ChatGPT and Rovo

A successful Sprint isn't just about finishing tasks—it’s about spotting risks before they become blockers. In this session, we leverage Atlassian Rovo to turn ChatGPT into a high-level project consultant. You will learn how to perform a "Sprint Health Check" using natural language, allowing you to instantly identify scope creep, stalled tickets, and bottlenecked team members without manually digging through burndown charts or complex filters.

Key Learning Objectives

• The AI Health Check Framework:

  • Understanding how Rovo queries live Sprint data to provide a real-time "pulse" of your project.

  • Learning the difference between raw data (Jira tickets) and AI insights (what that data actually means for your deadline).

• Identifying Delivery Risks:

  • Using prompts to find "stuck" work: "Rovo, show me any tickets that haven't moved in the last 3 days."

  • Spotting "Scope Creep": Asking the AI to identify issues added to the Sprint after it was already started.

• Analyzing Team Workload:

  • How to ask ChatGPT for a balance check: "Is the work evenly distributed across the team, or is one developer overloaded?"

  • Identifying potential bottlenecks in the "In Review" or "Testing" columns.

• Predictive Insights:

  • Asking the AI to forecast completion: "Based on our current velocity, are we on track to finish all committed stories by Friday?"

• Summarizing for Stakeholders:

  • Using ChatGPT to transform Sprint data into a concise "Health Summary" that can be shared in Slack or via email in seconds.

Who Is This For?

• Scrum Masters: Conduct more effective Daily Stand-ups by having the AI highlight exactly where the team needs to focus.

• Project & Product Managers: Get an instant, objective view of Sprint progress to manage stakeholder expectations.

• Team Leads: Identify team members who might be struggling with specific tasks before the end of the iteration.

• PMO Professionals: Monitor multiple Sprints simultaneously by asking Rovo for high-level health comparisons.

Practical Takeaway

By the end of this lecture, you will have a "Digital Assistant" that watches over your Sprint. You’ll move from reactive management (finding problems at the end of the Sprint) to proactive leadership—using AI to surface the most critical information at exactly the right time.

Lecture Goal: To master the art of the "AI-Driven Stand-up." You will leave this session with the ability to interrogate your Sprint data through ChatGPT, ensuring your team stays on track and your delivery remain predictable and transparent.

The content is designed for project managers, scrum masters, product owners, team leads, and PMO professionals who want to understand how AI teammates can practically support their projects. It’s also suitable for business analysts, coordinators, and aspiring project leaders who are curious about leveraging AI to reduce manual overhead and improve visibility across their work. No prior experience with Rovo® or AI agents is required; a basic familiarity with project management concepts is enough to benefit from this lesson.

Lecture Description: Limitations of Atlassian Rovo via ChatGPT

While AI teammates are transformative, they are not magic. To use Atlassian Rovo effectively, you must understand its boundaries. In this session, we take a pragmatic look at the current limitations of the Rovo and ChatGPT integration. We will discuss technical constraints, safety guardrails, and common "hallucinations" to ensure you can build reliable workflows without being blindsided by AI errors.

Key Learning Objectives

• The Permission Mirror (Visibility Limits):

  • Understanding that Rovo is strictly permission-aware: It cannot "see" or "search" any data that your specific Jira/Confluence user account doesn't already have access to.

  • Why a "failed search" in Rovo might actually be a permission issue in Jira.

• Credit Allowances & Quotas:

  • Navigating the Rovo Credit System: Understanding how requests to ChatGPT and Rovo Agents consume monthly credits.

  • Identifying the cost difference between a standard chat query and "Deep Research" mode.

• The "Write-Action" Guardrails:

  • Understanding the manual confirmation requirement: Why Rovo (by default) prompts you to confirm before it creates or deletes an issue.

  • Current limitations on complex "Bulk Edits" (e.g., transitioning 100 tickets at once might still require manual Jira intervention).

• The Hallucination Factor:

  • Identifying "Confident Errors": How ChatGPT might suggest a Jira feature or ticket status that doesn't actually exist in your project configuration.

  • The importance of the Source Citation: Learning to always click the reference link to verify the AI's claims against the original document.

• Technical & Domain Constraints:

  • Latency: Managing expectations around response times when Rovo is fetching data from multiple external connectors (Google Drive, Slack, GitHub).

  • Generic Domains: Why Rovo cannot be enabled for organizations using generic emails (like @gmail.com) and requires a verified business domain.

• Data Residency & Compliance:

  • Knowing the boundaries of where your data goes: How "Zero-Retention" policies protect you, but also mean the AI doesn't "remember" previous conversations once a session is cleared.

Managing the "Gaps"

• Trust but Verify: Treat every AI-generated Jira ticket as a draft. Always review the summary and description before hitting "Save."

• Context is King: If Rovo can't find an issue, try providing the specific Issue Key (e.g., PROJ-123) to help it narrow its search parameters.

• Security First: Remember that while Atlassian doesn't train models on your data, the AI accelerates discovery—meaning if your Confluence permissions are "messy," Rovo will make that sensitive data much easier for the wrong people to find.

Who Is This For?

• Jira Admins & PMO Leads: To set realistic expectations for the team and manage AI budgets.

• Project Managers & Scrum Masters: To troubleshoot why a rule or agent might not be returning the expected results.

• Stakeholders: To understand the "human-in-the-loop" necessity when reviewing AI-generated reports.

Lecture Goal: To move from AI "hype" to AI "competence." You will leave this session with a clear understanding of what Rovo can and cannot do, allowing you to design smarter, more resilient project management workflows that account for the quirks of Generative AI.

Use ROVODEV and connect to Atlassian's source code management tool i.e. Bitbucket

The content is designed for project managers, scrum masters, product owners, team leads, and PMO professionals who want to understand how AI teammates can practically support their projects. It’s also suitable for business analysts, coordinators, and aspiring project leaders who are curious about leveraging AI to reduce manual overhead and improve visibility across their work. No prior experience with Rovo® or AI agents is required; a basic familiarity with project management concepts is enough to benefit from this lesson.

Lecture Description: Connecting Rovo Dev to a Source Code Management Tool

Project management and software development often live in separate worlds, but Rovo Dev is designed to bridge that gap. In this session, we move into the technical engine of the Rovo ecosystem. You will learn how to connect Rovo Dev to your Source Code Management (SCM) tools—specifically GitHub Cloud, GitLab, or Bitbucket Cloud. By the end of this lecture, your AI agent will not just know about your tasks; it will have the context of your actual codebase to help with technical planning and execution.

Key Learning Objectives

• What is Rovo Dev?

  • Distinguishing between "Standard Rovo" (Knowledge & Search) and "Rovo Dev" (Action-oriented AI for coding and technical workflows).

  • Understanding the Teamwork Graph: How Rovo Dev maps the relationship between a Jira ticket and the specific code files it affects.

• The Integration Workflow:

  • Navigating the Atlassian Admin hub to the Connectors section.

  • Step-by-step authorization for GitHub, GitLab, or Bitbucket.

  • Configuring Repository Permissions: Ensuring Rovo Dev has "Read" access for context and "Write" access for drafting Pull Requests in safe sandboxes.

• Contextual Awareness:

  • How Rovo Dev uses the SCM connection to "read" your repository structure, READMEs, and existing patterns to provide code-aware suggestions.

  • Setting up Custom Instructions at the repository level so Rovo Dev follows your team's specific coding standards and PR templates.

• Connecting the IDE:

  • A first look at the Rovo Dev VS Code Extension: Bringing your Jira context and SCM data directly into your coding environment.

• Security & Privacy Guardrails:

  • Understanding how Atlassian secures your source code: Why Rovo Dev uses an isolated sandbox for code execution and testing before anything reaches your main branch.

Why Connect Your Code?

• Automated Technical Planning: Ask Rovo Dev, "Based on this Jira ticket and our current codebase, which files do I need to modify?"

• Instant PR Descriptions: Let the AI analyze your code changes and draft a comprehensive Pull Request description linked back to the Jira issue.

• Code Review Assistance: Use Rovo Dev as a "first pass" reviewer to check for technical risks or deviations from your documented standards.

Practical Takeaway

By the end of this lecture, you will have established the "technical nervous system" of your AI-powered project. You’ll be ready to move beyond just talking about tasks and start using Rovo Dev to assist with the actual technical delivery, ensuring that your Jira tickets and your code stay perfectly in sync.

Lecture Goal: To transform Jira from a "tracking tool" into an "execution hub." You will leave this session with a live connection between your project management office and your source code, enabling a seamless flow from requirement to pull request.

The content is designed for project managers, scrum masters, product owners, team leads, and PMO professionals who want to understand how AI teammates can practically support their projects. It’s also suitable for business analysts, coordinators, and aspiring project leaders who are curious about leveraging AI to reduce manual overhead and improve visibility across their work. No prior experience with Rovo® or AI agents is required; a basic familiarity with project management concepts is enough to benefit from this lesson.

Lecture Description: Writing Code via Rovo Dev—From Jira to Pull Request

The dream of "issue-to-code" is now a reality. In this session, we explore the core functionality of Rovo Dev: generating actual source code directly from a Jira work item. You will learn how to launch a secure, AI-powered coding session that uses your Jira requirements as a blueprint to write, test, and propose code changes in your repository.

Key Learning Objectives

• Launching a Rovo Dev Session:

  • Locating the "Code this task" button within a Jira issue.

  • Understanding the Cloud Sandbox: How Rovo Dev creates a secure, isolated environment to work on your code without affecting your local machine.

• The "Plan-First" Approach:

  • Learning why Rovo Dev drafts a Code Plan before writing a single line of code.

  • How to review, edit, and approve the plan to ensure the AI's technical approach matches your team's architecture.

• Contextual Code Generation:

  • How Rovo Dev pulls context from the Teamwork Graph: Using the Jira description, linked Confluence specs, and existing repo patterns to write "relevant" code.

  • Adding specific files as context: Manually guiding the AI to the exact components or utilities it should reference.

• The Iterative Loop (Refine & Edit):

  • Using the Rovo Dev chat interface to request changes (e.g., "Refactor this to use a custom hook" or "Add unit tests for the edge cases").

  • Reviewing "Diffs" in the browser: How to spot changes, additions, and deletions made by the AI.

• Automated Testing & Debugging:

  • Running your test suite within the Rovo Dev sandbox.

  • How the AI self-corrects: If a test fails, Rovo Dev can analyze the error logs and automatically iterate on the code until it passes.

• Creating the Pull Request:

  • Finalizing the session: Automatically pushing the changes to a new branch and opening a Draft Pull Request in GitHub, GitLab, or Bitbucket.

Practical Use Cases for Teams

• The "Blank Page" Problem: Use Rovo Dev to generate the initial boilerplate for a new feature or API endpoint based on your PRD.

• Bug Remediation: Provide a bug report in Jira and have Rovo Dev scan the repo, identify the faulty code, and propose a fix.

• Modernization & Cleanup: Automate the cleanup of feature flags or the migration of components from one library version to another across the entire codebase.

A Developer-Led Experience

It is important to remember that Rovo Dev is AI-powered but Developer-led. While the AI handles the "busywork" of writing the code, the human developer remains the ultimate authority, reviewing the code plan, approving the changes, and performing the final merge of the Pull Request.

Lecture Goal: To master the art of "Agentic Programming." You will leave this session with the ability to turn a Jira ticket into a functional Pull Request in minutes, significantly reducing the manual effort of implementation while maintaining high code standards.

Lecture Description: Understanding the Rovo Dev Usage Report

As you scale AI across your engineering team, keeping an eye on consumption and performance is vital for both budget and efficiency. In this session, we dive into the Rovo Dev Usage Report. You will learn how to access the Admin dashboards to track AI adoption, monitor your credit allowances, and understand how "Rovo Dev credits" differ from standard Rovo credits.

Key Learning Objectives

• Navigating the Admin Dashboards:

  • How to find your reports: Moving through Atlassian Administration > Security > Insights > AI Usage.

  • Understanding the difference between the Adoption tab (who is using AI) and the Agents tab (which automations are running).

• Demystifying the Credit Systems:

  • Rovo Credits vs. Rovo Dev Credits: Learning how standard tasks (Chat, Search) and technical tasks (CLI, Code Generation, Code Review) draw from separate pools.

  • Consumption Metrics: Understanding the "cost" of technical actions—for example, how a single code review or a complex CLI task impacts your monthly allowance.

• Tracking Individual & Team Adoption:

  • Identifying Active Users vs. Users with AI enabled: Measuring how deeply the team is actually integrating Rovo into their daily work.

  • Rovo Interactions: Analyzing the volume of AI-generated content and identifying the most popular apps (Jira vs. Bitbucket vs. Confluence) for AI engagement.

• Monitoring Agent Performance:

  • Tracking Agent Runs and Success Rates: Seeing which custom agents are providing the most value and which ones might need better instructions.

• Budgeting and Scaling:

  • Using the Usage Over Time line graphs to project future needs.

  • Setting up notifications: How to check how close you are to your monthly limit before the AI stops "acting" for the billing cycle.

• Exporting Data for Governance:

  • Learning how to export usage trends as CSV files for deeper analysis in tools like Excel or Google Sheets, perfect for PMO reporting or executive summaries.

The "Source of Truth" for Admins

• Platform Usage Dashboard: Use this for official billing and to see exactly how many credits remain in your organization's "pooled" allowance.

• Rovo Trends: Use this to understand the behavior of your team—seeing which features (like "Deep Research") are gaining the most traction.

Who Is This For?

• Jira Admins & IT Managers: To manage licensing, credits, and ensure the organization is getting a return on its AI investment.

• Engineering Managers & Team Leads: To see if the team is successfully adopting Rovo Dev or if they need more training on specific tools like the CLI.

• PMO Professionals: To provide data-backed reports on how AI is reducing manual overhead across the project lifecycle.

Lecture Goal: To turn you into a data-driven AI administrator. By the end of this video, you will know exactly where your AI credits are going, which team members are your "Power Users," and how to manage your Rovo Dev resources to ensure your projects never hit a technical bottleneck.

In this video we'll learn how to create our own custom issue type.

Lecture Description: Creating Custom Issue Types

Standard issue types like "Task" or "Bug" are great for general work, but sometimes your project needs a specific category that fits your unique process. In this session, we dive into Custom Issue Types. You will learn how to define, create, and manage your own work categories—such as "Risk," "Change Request," or "Design Asset"—to give your team better clarity and specialized workflows for different kinds of deliverables.

Key Learning Objectives

• The Power of Customization:

  • Understanding when to create a new issue type vs. when to use a label or custom field.

  • Exploring common custom types: Initiatives for high-level goals, Risks for project management, and Research for discovery work.

• Creating a New Issue Type (Admin Walkthrough):

  • Navigating to Jira Settings > Issues > Issue Types.

  • Defining the Name and Description: Ensuring team members understand exactly what this type is used for.

  • Choosing the Issue Type Avatar: Selecting distinct icons to make your new type stand out on the Kanban or Scrum board.

• Hierarchy and Schemes:

  • Standard vs. Sub-task: Deciding if your new type is a top-level work item or a child of another issue.

  • Issue Type Schemes: Learning how to group your new type with others and associate it with specific projects so it only appears where it's needed.

• Designing Unique Workflows:

  • Understanding that a "Bug" follows a different path than a "Risk."

  • How to link your custom issue type to a dedicated workflow with its own unique statuses and transitions.

• Field Configuration:

  • Tailoring the "Create" screen: Ensuring that when someone creates your custom issue type, they are only prompted for the data that matters (e.g., a "Risk" needs a "Probability" field, but a "Task" might not).

Best Practices for Custom Types

• Avoid Over-Categorization: Only create a new issue type if it requires a different workflow or a different set of mandatory fields. Too many types can confuse the team.

• Standardize Icons: Use a consistent visual language across your Jira instance so users can identify the "type" of work at a glance from the backlog.

• Review and Prune: Regularly check your usage reports. If a custom issue type hasn't been used in six months, consider merging it back into a standard "Task."

Who Is This For?

• Jira Administrators: To learn the technical steps of system-level configuration.

• Project Managers & PMO Leads: To design a tracking system that mirrors their real-world reporting requirements.

• Scrum Masters: To help teams visualize specialized work (like technical debt or spikes) more effectively.

Lecture Goal: To make Jira adapt to your process, not the other way around. By the end of this video, you will be able to build a bespoke work environment that tracks exactly what your team produces, with the right fields and workflows to support every unique piece of work.

In this video we'll learn how to create and use our own custom fields.

Lecture Description: Creating and Using Custom Fields

While Jira’s default fields (like Summary and Priority) cover the basics, most projects require specific data points to drive reporting and automation. In this session, we explore Custom Fields. You will learn how to go beyond generic text boxes and build a structured data environment that captures the exact information your stakeholders need—whether it’s a "Business Value" score, a "Customer Segment," or a "Target Release Date."

Key Learning Objectives

• The Strategy of Field Design:

  • Understanding the "Field vs. Form" decision: When to create a permanent database field and when to use a simple intake form.

  • The Golden Rule: Reuse before you create. How to search for existing fields to prevent "field bloat" in your Jira instance.

• Creating a New Custom Field (Step-by-Step):

  • Navigating to Jira Settings > Issues > Custom Fields.

  • Standard vs. Advanced Types: Choosing between common types like Checkboxes, Date Pickers, and Select Lists (dropdowns), or advanced types like User Pickers and URL fields.

  • Naming and Descriptions: Best practices for naming fields generically (e.g., "Objective" vs. "Marketing Q3 Objective") to allow for cross-project reuse.

• The "Screen" Connection:

  • Understanding that a field exists but isn't visible until it’s added to a Screen.

  • How to associate your new field with the "Create," "Edit," and "View" screens of your specific project.

• Field Configuration & Context:

  • Required vs. Optional: Learning how to make a field mandatory so that users can't create a ticket without providing critical data.

  • Contextual Values: How to set different dropdown options for the same field depending on which project it is being used in.

• Governance and Cleanup:

  • Monitoring field usage: How to identify and prune "orphan" fields that are no longer used by any team.

  • Understanding the 2026 performance limits: Staying within the 700-field cap per configuration to keep your Jira instance fast and reliable.

Practical Use Cases for Leaders

• Prioritization: Create a "WSJF" (Weighted Shortest Job First) number field to help the team rank the backlog objectively.

• Visibility: Add a "Stakeholder Department" dropdown to track which parts of the business are requesting the most work.

• Compliance: Use a "Security Reviewed" checkbox to ensure no feature moves to "Done" without meeting safety standards.

Common Pitfalls to Avoid

• Cryptic Names: Avoid abbreviations like "T_Lvl_1." Instead, use "Technical Complexity Level."

• Too Much Free Text: Whenever possible, use Select Lists (dropdowns) instead of text fields. Dropdowns provide clean data for Jira Query Language (JQL) reporting, whereas text fields are prone to typos.

• Global Bloat: Always try to limit your field's "Context" to the specific projects that need it, rather than making every custom field global by default.

Who Is This For?

• Jira Administrators: To master the technical setup and governance of the field schema.

• Product Owners: To ensure the backlog captures the specific data needed for roadmap planning.

• Project Managers: To build the custom reporting views required for executive status updates.

Lecture Goal: To transform Jira into a high-fidelity data tool. By the end of this video, you will be able to design and deploy custom fields that make your issues more informative, your reporting more accurate, and your automation more powerful.

In this video we'll learn about a concept Jira uses calls schemes for screen layout.

Lecture Description: Understanding Screen Schemes and Layouts

In Jira, a "Screen" is simply a collection of fields. However, Jira doesn't just show one screen for everything; it uses a system of Schemes to determine which fields appear at which stage of a task's life. In this session, we break down the logic behind Screen Schemes and Issue Type Screen Schemes—the blueprint that controls the user interface of your projects.

Key Learning Objectives

• The Three Operations:

  • Understanding the three distinct moments Jira displays a screen: Create (opening a new ticket), Edit (modifying an existing ticket), and View (looking at the ticket details).

  • Why you might want a "slim" Create screen (to encourage quick entry) but a "detailed" View screen (for deep data).

• Defining the Screen Scheme:

  • Learning how a Screen Scheme maps specific screens to the three operations mentioned above.

  • How the "Default" screen acts as a fallback for any operation you don't explicitly configure.

• The Issue Type Screen Scheme (The Master Blueprint):

  • Understanding the hierarchy: How this scheme bridges the gap between your Issue Types (Bug, Story, Task) and your Screen Schemes.

  • Example: Configuring Jira so that a "Bug" requires an "Environment" field during creation, while a "Story" does not.

• The "Project Association" Step:

  • Learning how to apply these schemes to a project.

  • Understanding that changes made at the scheme level can affect multiple projects simultaneously—mastering the "configure once, deploy many" approach.

• Screens vs. Space Layouts:

  • Exploring the 2026 Layout Editor: How Space Admins can now reorder and hide fields locally without needing a Global Jira Admin to change the underlying Screen Scheme.

The "Why" Behind Schemes

• Reduced Clutter: By using schemes, you ensure that your team isn't overwhelmed by 50 fields when they are just trying to quickly log a bug.

• Data Integrity: You can make certain fields mandatory on the "Edit" screen that weren't required during "Create," ensuring that as a task progresses, the necessary data is collected.

• Consistency: Schemes allow you to maintain a standardized look and feel across your entire department or organization while still allowing for "niche" requirements for specific teams.

Pro-Tips for Configuration

1. Keep it Simple: Start by using the same screen for all three operations. Only branch into multiple screens if there is a strong business reason to hide or show specific fields.

2. Naming Conventions: Always name your schemes clearly (e.g., [PROJ] Software Development Screen Scheme) so other admins can understand the purpose at a glance.

3. The "Hidden" Field Trick: If a field is on your screen but doesn't appear when you view an issue, it’s likely because the field is empty. Jira hides empty fields by default to keep the interface clean.

Who Is This For?

• Jira Administrators: To understand the structural "plumbing" of the Jira UI.

• Project Managers: To design a user experience that balances data collection with team speed.

• PMO Leads: To ensure standardized reporting fields are visible across all project types in the organization.

Lecture Goal: To master the "Logic of the Layout." By the end of this video, you will understand how Jira decides which fields to show and when, giving you total control over the user experience of your project.

In this video we'll learn about the concept of workflows in Jira.

Lecture Description: Mastering Custom Workflows in Jira

Every team has its own unique definition of "Done" and a specific path to get there. In this session, we explore the engine that drives Jira's flexibility: Custom Workflows. You will learn how to move beyond the basic "To Do, In Progress, Done" and design a digital lifecycle that mirrors your team's real-world processes—ensuring transparency, accountability, and smoother delivery.

Key Learning Objectives

• The Anatomy of a Workflow:

  • Statuses: Defining the "stations" where work stops (e.g., In Review, Waiting for Approval, Ready for Testing).

  • Transitions: Building the paths that connect those statuses. You’ll learn that transitions are one-way streets—if you want to move work back and forth, you need two separate paths!

• Status Categories (The Colors of Jira):

  • Understanding the three global buckets: To Do (Grey), In Progress (Blue), and Done (Green).

  • Why every custom status must live in one of these categories to keep your Burndown charts and Gadgets accurate.

• Transitions & Rules:

  • Conditions: Controlling who can move a ticket (e.g., only a Lead can transition to "Approved").

  • Validators: Ensuring data is present before a move (e.g., requiring an "Estimated Hours" field before moving to "In Progress").

  • Post Functions: Automating actions after a move (e.g., automatically assigning the ticket to a QA Engineer when it moves to "Ready for Testing").

• The "Resolution" Field:

  • Understanding why a "Done" status isn't enough. You’ll learn how to use the Resolution field to track why a ticket was closed (e.g., Fixed, Won’t Do, Duplicate).

• Workflow Schemes (The Connection):

  • Learning how to map different workflows to different issue types.

  • Example: Configuring your project so that "Bugs" follow a rigorous "Fix & Verify" path while "Tasks" follow a simple "To Do > Done" path.

• The 2026 Workflow Editor:

  • Navigating the modern visual designer to drag-and-drop statuses and create "All" transitions (allowing an issue to move to a status from anywhere else).

Best Practices for Workflow Design

• Keep it Lean: Every status adds "friction." If a team doesn't actually stop to perform a specific action, don't give it a status.

• Gerunds vs. Past Tense: Use "In Review" (active) rather than "Reviewed" (finished) for statuses. This tells the viewer what is happening now.

• The "Kill Switch": Always ensure there is a path to "Cancel" or "Won't Do" from almost every status so work doesn't get stuck in a loop.

Who Is This For?

• Jira Administrators: To learn the technical mechanics of building and publishing active workflows.

• Scrum Masters & Team Leads: To help their teams visualize bottlenecks (e.g., if work is constantly piling up in a "Peer Review" status).

• PMO Professionals: To standardize the definition of "Done" across multiple projects for accurate executive reporting.

Practical Takeaway

By the end of this lecture, you will be able to translate a messy, real-world business process into a clean, automated Jira workflow. You’ll move from being a user who just "clicks buttons" to an architect who designs the system that keeps the whole team moving in the right direction.

Lecture Goal: To make the work "flow." You will leave this session with the skills to build a customized, high-performance lifecycle that eliminates ambiguity and ensures every team member knows exactly what needs to happen next.

Lecture Description: Mastering Jira Permissions

In a collaborative environment, balancing transparency with security is critical. In this session, we demystify the Jira Permission Hierarchy. You will learn how to ensure the right people have access to the right information without compromising sensitive data or accidentally allowing unauthorized changes to your project configuration.

Key Learning Objectives

• The Three Layers of Security:

  • Global Permissions: System-wide settings (e.g., "Who can create a project?" or "Who can log in?").

  • Project Permissions: The core of Jira security—controlling what users can do within a specific project (e.g., "Who can transition issues?" or "Who can delete comments?").

  • Issue Security Levels: The most granular layer—allowing you to hide specific tickets within a project from certain users.

• Permission Schemes (The Blueprint):

  • Understanding the "Configure Once, Apply Often" model.

  • Learning how to map Project Roles, Groups, and Individual Users to specific actions like Browse Projects, Create Issues, and Assign Issues.

• Roles vs. Groups:

  • Groups: Global collections of users (e.g., "All-Employees," "Site-Admins").

  • Project Roles: Flexible buckets that change per project (e.g., "Developer," "Stakeholder"). You will learn why using Project Roles in your schemes is the secret to scalable administration.

• Common Permission Pitfalls:

  • The "Hidden Project" mystery: Why a user can't see a project even if they have a direct link (the Browse Projects permission).

  • The danger of "Delete" permissions: Best practices for restricting who can permanently remove issues or worklogs.

• Troubleshooting Access:

  • Using the Permission Helper: A powerful admin tool to instantly diagnose why a specific user can or cannot perform a certain action.

Best Practices for Project Leaders

• Follow the Principle of Least Privilege: Only give users the permissions they absolutely need to do their jobs.

• Standardize Schemes: Avoid creating a unique permission scheme for every single project. Aim for "Standard Software" and "Strict/Private" templates to keep your instance manageable.

• Empower Project Leads: By using Project Roles, you allow project managers to add or remove team members themselves without needing to contact a Jira Admin every time a new person joins the team.

Who Is This For?

• Jira Administrators: To learn how to build and maintain secure, scalable permission architectures.

• Project Managers: To understand how to manage their team’s access levels and protect their project data.

• PMO Leads: To ensure organizational compliance and data privacy standards are met across all Jira boards.

Practical Takeaway

By the end of this lecture, you will move from "guessing" why someone can't access a ticket to "architecting" a secure environment. You will have the confidence to set up complex project access rules that keep your workspace organized, secure, and professional.

Lecture Goal: To provide a clear, "no-headache" guide to Jira security. You will leave this session with a practical framework for managing users and permissions that scales with your organization’s growth.