Project Manager Skillpath: Agile, Scrum, SAFe® & Jira®

By the end of this lesson, learners will clearly understand why traditional software development approaches struggled in modern environments and what fundamentally drove the shift toward more adaptive, Agile-based ways of working. You will be able to:
- Explain the core limitations of classic waterfall and plan-driven methods (late feedback, brittle requirements, high risk of rework, and slow time-to-market).
- Describe how changing market dynamics, customer expectations, and technology complexity exposed these limitations.
- Articulate the business and project risks of long delivery cycles and inflexible planning.
- Connect these pain points directly to the principles that Agile, Scrum, and scaled approaches such as SAFe® are designed to solve.
- Use this historical and practical context to justify an Agile transition to stakeholders, sponsors, and team members who may be skeptical.

This lesson is conceptual and does not require hands-on use of tools. However, it sets the foundation for later, more practical lessons that will explore how Agile frameworks like Scrum and scaled frameworks like SAFe® are implemented using modern work-management tools such as Jira®. Understanding why software development needed a change will make it much easier to see how these tools and frameworks address real-world delivery challenges.

The lesson is designed for current and aspiring project managers, Scrum Masters, product owners, team leads, business analysts, and anyone transitioning from traditional project management to Agile environments. It’s also valuable for software developers, QA engineers, and technical stakeholders who want to understand the broader rationale behind Agile, Scrum, SAFe®, and the use of Jira® in professional project management settings.

By the end of this lesson, learners will clearly understand the 12 principles behind the Agile Manifesto and how they translate into day-to-day project management decisions. You will be able to interpret each principle in practical terms, link it to real-world project scenarios, and explain why these principles often lead to better outcomes than traditional, plan-driven approaches. You’ll also be able to recognize when an initiative is violating an Agile principle and propose concrete, practice-oriented adjustments to get back on track—such as improving customer collaboration, restructuring work into smaller increments, or shortening feedback loops.

You will practice mapping the 12 principles to familiar project constraints like scope, schedule, budget, and quality so you can justify Agile choices to stakeholders and leadership. By connecting each principle to behaviors—like frequent delivery, welcoming changing requirements, sustainable pace, and continuous improvement—you’ll gain the confidence to champion Agile ways of working within your team and organization, even if you’re transitioning from a waterfall or hybrid model. This lesson equips you to use Agile principles as a decision-making compass for choosing appropriate frameworks (Scrum, Kanban, SAFe) and practices in later parts of the program.

This specific lecture is concept-focused and does not require hands-on use of tools or technologies. However, it will lay the conceptual foundation for how these 12 principles manifest when you later manage work using Agile tooling such as Jira and other project tracking systems. You will see conceptual references to Agile boards, backlogs, and iterative delivery, but the emphasis here is on mindset and principles rather than tool configuration.

This lesson is designed for current and aspiring project managers, Scrum Masters, Product Owners, business analysts, team leads, and professionals in PMO or delivery roles who want to understand not just “how” to do Agile, but “why” Agile works. It’s also valuable for stakeholders and managers in product, engineering, operations, or business functions who frequently interact with Agile teams and need a concise, structured understanding of the principles that drive Agile behavior and ceremonies.

By the end of this lesson, learners will be able to clearly distinguish what Agile truly is from what it is not, breaking down the most common myths that derail effective implementation. You will learn how to explain Agile beyond buzzwords, recognize when an organization is “doing Agile” in name only, and identify red flags such as confusing “no documentation” with “just enough documentation,” equating Agile with “no planning,” or believing that “Agile means no deadlines or commitments.” You’ll also gain the ability to counter misconceptions around Agile being “only for software,” “only for small teams,” or “a silver bullet that fixes everything,” and instead articulate how Agile practices can scale, adapt to different environments, and coexist with governance, compliance, and traditional project expectations. By the end, you’ll be ready to communicate Agile concepts confidently to stakeholders, defend Agile choices with evidence and logic, and avoid the traps that cause Agile, Scrum, SAFe®, and Jira® initiatives to fail before they truly begin.

This lesson is concept-focused and does not require you to use any specific tools or technologies hands-on. However, it explicitly references Agile delivery frameworks such as Scrum and scaled approaches like SAFe®, and uses Jira® as a real-world example when debunking myths such as “we’re Agile because we use an Agile tool.” You will understand how tools like Jira® support Agile practices but do not, by themselves, make a team Agile, and how framework labels (Scrum, SAFe®) can be misused when underlying principles are ignored.

The lesson is designed for current and aspiring project managers, Scrum Masters, Product Owners, team leads, and delivery managers who are transitioning from traditional project management or hybrid environments and want to use Agile effectively rather than superficially. It is equally valuable for business stakeholders, analysts, and managers who work with Agile teams and need clarity on what to expect from Agile projects and what “being Agile” truly entails. Whether you’re preparing for a formal Agile role or simply need to collaborate intelligently in Agile, Scrum, SAFe®, and Jira®–driven initiatives, this lesson provides the foundation to cut through hype, challenge misconceptions, and set realistic expectations for Agile adoption.

By the end of this lesson, learners will be able to clearly distinguish when a traditional, plan-driven approach is appropriate versus when an adaptive approach is the better choice. You will unpack the core principles, strengths, and limitations of each delivery model, then compare them side by side using real-world project scenarios. You’ll learn to map project characteristics—such as requirement stability, risk level, regulatory constraints, stakeholder involvement, and time-to-market pressure—to the delivery approach that best fits.

You’ll also be able to identify common failure patterns that occur when the wrong model is chosen, and articulate how to transition from a rigid, linear sequence of phases to a more iterative, incremental way of working without losing essential controls. The lesson will help you explain to stakeholders why a hybrid or fully adaptive approach may reduce risk, improve predictability of value delivery, and foster better collaboration across teams. By the end, you’ll be capable of justifying your choice of delivery model in language that executives, product owners, and technical teams can all understand.

This lesson is primarily conceptual and comparative; no specialized software tools are required. Any examples that touch on tooling are high-level and focus on illustrating how work is planned and tracked in different delivery models, rather than providing hands-on configuration or step-by-step tool training.

The content is intended for current and aspiring project managers, Scrum Masters, team leads, and product owners who need to make informed decisions about how to structure and manage projects. It is also highly relevant for business analysts, QA leads, and stakeholders from business or IT who are transitioning from traditional project environments to more adaptive ways of working, or who operate in organizations experimenting with or scaling iterative delivery approaches across multiple teams.

In this lesson, you’ll explore the real-world advantages and trade-offs of adopting agile ways of working, so you can decide when, where, and how to use agile practices effectively in your projects. By the end of the session, you’ll be able to clearly articulate the core business benefits of agile—such as faster time to market, improved customer alignment, better risk management, and higher team engagement—and explain how these benefits differ from traditional, plan-driven approaches. You’ll also be able to recognize the limitations of agile, including the organizational constraints, team readiness, and project types where agile may not be the best fit, and you’ll know how to balance agile with existing governance or compliance demands.

You will learn to map agile benefits to concrete project outcomes, so you can build a compelling case for agile adoption with stakeholders and leadership. You’ll practice evaluating sample project scenarios and deciding whether a fully agile, hybrid, or traditional approach makes sense, based on uncertainty, complexity, stakeholder involvement, and regulatory constraints. You’ll also gain the language and confidence to push back on “agile as a buzzword,” distinguishing genuine agile value from superficial label changes or tool-only transformations.

This lesson is conceptual and does not require any specific software or tools. You will see illustrative references to common agile environments—for example, Scrum boards and Jira-style issue tracking—to show how agile benefits are realized in day-to-day work, but you won’t need to install or use any technology during the lecture. The focus is on understanding the principles, trade-offs, and decision criteria behind using agile, rather than on hands-on tool configuration.

The content is designed for current and aspiring project managers, Scrum Masters, product owners, team leads, business analysts, and professionals moving from traditional project management into agile practices. It is equally valuable for people working in organizations that are considering an agile transition, struggling with partial agile adoption, or operating in hybrid environments that combine agile and non-agile approaches. Stakeholders such as line managers, sponsors, and PMO members who need to evaluate when agile will truly help—and when it may not—will also benefit from this lesson.

By the end of this lesson, learners will understand the non‑negotiable core concepts that make Agile work in real project environments and be able to apply them immediately in their day‑to‑day management practice. You will be able to clearly explain the Agile mindset and values, distinguish them from traditional project management thinking, and translate them into practical team behaviors. You’ll learn how to break work into user stories and value‑driven increments, define and use a clear Definition of Ready and Definition of Done, and apply concepts like timeboxing, prioritization, and empirical process control to improve delivery predictability. The lesson will also enable you to map the flow of work from idea to delivery using basic Agile workflow concepts, recognize and reduce common sources of waste, and use feedback loops and ceremonies to drive continuous improvement. By the end, you’ll be equipped to speak confidently about essential Agile terminology with stakeholders and teams and make informed decisions about when and how to apply these concepts in different project contexts.

This lesson is primarily conceptual, with light reference to digital tools that support Agile work. You’ll see how these must‑know Agile concepts show up inside typical Agile tooling such as digital boards, backlogs, and dashboards, and how these features underpin practices like iterative delivery, work‑in‑progress limits, and transparency. While you won’t need to operate any specific software during this lecture, the concepts are presented in a way that makes it easy to recognize and apply them later in common platforms used in Agile and Scrum environments.

The lesson is designed for aspiring and current project managers, Scrum Masters, team leads, business analysts, and product owners who need a solid, practical grasp of Agile fundamentals. It’s equally suitable for professionals transitioning from traditional (waterfall) project management, as well as stakeholders such as product managers, PMO members, and line managers who collaborate with Agile teams and must understand how Agile concepts influence planning, reporting, and delivery. No prior hands‑on Agile experience is required—only a willingness to adopt a more iterative and value‑focused way of working.

In this lesson you’ll learn how to transform big ideas into small, actionable pieces of work that flow smoothly through any Agile, Scrum, or SAFe® environment. By the end, you’ll be able to clearly distinguish between themes, epics, features, and user stories, and understand when and why to use each. You’ll practice breaking down large initiatives into well-structured backlogs, write clear and testable user stories with acceptance criteria, and slice work into small increments that can realistically fit into a sprint or Program Increment. You’ll also gain confidence in prioritizing and organizing this work so that teams deliver value early and often, instead of getting stuck with vague, oversized requirements.

The lesson uses common Agile lifecycle tools such as Jira® as reference points for how themes, epics, and stories are represented and linked in a real-world tool. You’ll see how these work items typically appear in a backlog, how hierarchy and relationships are maintained, and how this structure supports reporting and tracking in Scrum and SAFe® contexts. While you won’t need to be an expert in any specific tool, you’ll understand how to map the concepts you learn directly into tools used on modern Agile projects, including Jira® and similar issue-tracking systems.

This lesson is designed for current and aspiring project managers, Scrum Masters, product owners, team leads, business analysts, and anyone transitioning from traditional project management to Agile ways of working. It is also well suited to professionals in organizations adopting Scrum or SAFe® who need to understand how to decompose large initiatives into manageable units of work, including PMO staff, product managers, delivery managers, and technical leads who collaborate on planning and managing Agile backlogs.

By the end of this lesson, learners will be able to confidently build, structure, and manage an Agile product backlog from scratch, using industry-standard techniques and real-world examples. You will learn how to transform vague ideas and stakeholder requests into clear, value-driven backlog items, prioritize them effectively, and keep the backlog healthy, transparent, and actionable for Scrum and scaled Agile environments.

This lesson dives deep into what makes a product backlog effective: clear, INVEST-ready items, properly sized and refined, with clear acceptance criteria and a logical ordering that reflects customer value and strategic priorities. You will practice breaking down epics into features and user stories, writing strong user stories that reflect the “who/what/why,” and defining acceptance criteria that support testable, done-ready work. You’ll also see how to manage dependencies, technical work, bugs, and enabler items alongside pure business value items so the team can deliver sustainably over time.

You will gain practical techniques for backlog prioritization, such as MoSCoW, value vs. effort matrices, and risk/value balancing, along with a pragmatic view of how priorities are negotiated across stakeholders. The lesson covers how to use backlog refinement (grooming) sessions effectively—what to discuss, who to invite, how often to refine, and how deep to go—so that sprint planning becomes smoother and more predictable. Special focus is given to the role of the Product Owner and Project Manager in collaborating with stakeholders and development teams to maintain a single, coherent source of truth for upcoming work.

Learners are introduced to applying these concepts in Jira®, including how to create and organize epics, user stories, tasks, and bugs, and how to use Jira boards and filters to visualize and maintain a healthy backlog. While the emphasis is on the concepts and techniques of backlog management, you will see how these map into Jira workflows commonly used by Agile teams. Concepts are also discussed in the context of Scrum and SAFe® environments, showing how team-level and program-level backlogs relate and how to keep alignment across multiple teams.

This lesson is designed for new and aspiring Project Managers, Scrum Masters, Product Owners, Business Analysts, and team leads who need to manage work in Agile teams, with or without prior Agile experience. It’s also valuable for traditional project managers transitioning from waterfall to Agile who want concrete, practical guidance on how to translate project requirements into a living backlog that supports iterative delivery. Junior and mid-level professionals looking to strengthen their Agile delivery toolkit, as well as stakeholders who work closely with Agile teams and want to understand how work gets organized and prioritized, will benefit from the clear, real-world approach used throughout the lecture.

In this lesson on **Delivering Faster with Minimum Viable Product**, you’ll learn how to apply the MVP mindset to accelerate delivery while still protecting quality and customer value. By the end, you will be able to:

- Clearly define what a Minimum Viable Product is (and what it is not) in the context of Agile delivery.
- Break down large project ideas into a focused MVP that validates assumptions quickly.
- Prioritize features ruthlessly using simple decision frameworks (e.g., MoSCoW, value vs. effort) to decide what truly belongs in the MVP.
- Translate MVP scope into a concrete initial backlog ready for planning in Scrum or other Agile approaches.
- Use feedback loops and iterative releases to evolve the MVP into a more complete solution while minimizing waste.
- Communicate the value and rationale of an MVP to stakeholders, sponsors, and teams to reduce resistance and manage expectations.
- Avoid common pitfalls such as releasing a “minimum” but not “viable” product, or overloading the MVP with unnecessary features.

This lesson is primarily conceptual and method-focused. It does not require specialized software, but it will reference and demonstrate how MVP thinking connects to common Agile tools such as:

- Digital boards or backlog tools (e.g., Jira or similar) for capturing and prioritizing MVP features and user stories.
- Simple templates and canvases (such as Lean-style hypothesis statements or feature breakdown worksheets) for defining and refining the MVP.

The content is designed for:

- New and aspiring project managers transitioning into Agile roles who need a clear, practical approach to delivering value early.
- Existing project managers and team leads who want to speed up delivery and reduce rework through MVP-based planning.
- Scrum Masters, Product Owners, and Agile practitioners seeking a structured way to define and defend MVP scope with stakeholders.
- Business analysts, product managers, and startup founders who need to validate ideas quickly and iteratively.

No prior deep technical background is needed—just a basic understanding of Agile principles and a desire to deliver value faster and smarter.

In this lesson, learners discover how to read, interpret, and create burndown charts so they can track Agile team progress with confidence. By the end, they will be able to explain what a burndown chart is, distinguish between ideal and actual burn lines, and quickly spot trends such as scope creep, under‑estimation, or impediments blocking delivery. Learners will practice walking stakeholders through a burndown chart, turning raw sprint data into clear visual insights that support better planning, daily standups, and sprint reviews. They will also learn how to use burndown charts to forecast whether a sprint or release is likely to finish on time and what corrective actions might be required.

The lesson demonstrates how burndown charts are generated and viewed in common Agile tools, focusing primarily on how to access and configure them in Jira®, including selecting boards, timeframes, and filters. Example charts are also shown in basic spreadsheet tools so learners understand the underlying data and can create simple burndowns even when full-featured Agile tooling is not available.

This content is designed for new and aspiring project managers, Scrum Masters, product owners, and team leads who are transitioning into Agile roles, as well as experienced traditional project managers who want to add practical Agile reporting skills. It is also well suited for team members in software development, IT, and business change initiatives who need to interpret burndown charts during Agile ceremonies and communicate progress to non-technical stakeholders.

In this hands-on lesson, you’ll walk through the complete process of building a burndown chart from scratch and learn how to use it to keep Agile projects on track. By the end, you’ll be able to:

- Explain what a burndown chart is and how it supports Agile, Scrum, and SAFe® planning and execution
- Identify the key data needed to create a burndown chart (sprint backlog, story points, remaining effort, dates)
- Construct a burndown chart step-by-step using simple tabular data
- Distinguish between ideal and actual burndown lines and interpret what the gap between them means
- Spot early warning signs of risk (scope creep, under- or over-estimation, blocked work) directly from the chart
- Use burndown insights to lead daily standups, adjust sprint plans, and communicate progress to stakeholders
- Apply best practices for keeping the chart accurate, up to date, and trusted by the team

The lesson demonstrates how to create and interpret burndown charts using:

- Jira® (Scrum boards and built-in reports)
- Spreadsheet tools such as Excel or Google Sheets to manually build and customize a burndown chart

This lesson is designed for:

- New and aspiring project managers, Scrum Masters, and Product Owners who want a clear, practical guide to burndown charts
- Experienced project managers transitioning from traditional (Waterfall) methods to Agile, Scrum, or SAFe®
- Team leads, business analysts, and coordinators who need to visualize sprint progress and communicate it to stakeholders
- Anyone preparing for Agile or Scrum-related certifications who needs a concrete, step-by-step understanding of burndown charts in planning and execution

In this hands-on session, you’ll move from simply “understanding” burndown charts to actually building and interpreting them like a working Agile project manager. By the end of the lesson, you will be able to construct a sprint burndown chart step‑by‑step from sample backlog data, track remaining work over time, and spot early indicators of risk such as scope creep, under‑commitment, and unsustainable pace. You’ll learn how to interpret trends in the chart to make real‑time decisions: when to re‑negotiate scope, when to swarm on blocked work, and how to use burndown insights in daily stand‑ups, sprint reviews, and stakeholder updates. You’ll also practice translating burndown data into clear, concise messages for non‑technical stakeholders and leadership, turning raw numbers into actionable, trustworthy forecasts.

The lesson includes a practical walkthrough using common productivity tools. You’ll see how to create and update a burndown chart in a spreadsheet (e.g., Excel or Google Sheets) from a simple sprint backlog, and how the chart evolves as work is logged as “done.” Where applicable, you’ll also see how modern Agile tools such as Jira® can automatically generate burndown charts from your board configuration, and what settings and fields must be correct (estimates, workflows, and statuses) for the charts to be meaningful. You’ll compare manual versus automated burndown generation so you understand what’s happening “under the hood” in any Agile tool.

This lesson is designed for new and aspiring project managers, Scrum Masters, Product Owners, team leads, and business analysts who want practical, real‑world skill in using Agile metrics to plan and control work. It’s equally valuable for traditional project managers transitioning from waterfall to Agile ways of working and for software or non‑software teams (marketing, operations, HR, etc.) who need to visualize progress and predict completion more reliably. No advanced math or prior burndown experience is required—only a basic understanding of sprints, user stories, and estimation.

In this lesson, you’ll learn exactly how to define, calculate, and use team velocity to plan and manage Agile work with confidence. By the end, you’ll be able to:

- Explain what velocity is and what it is *not* (and avoid common misuses and misconceptions).
- Calculate velocity from completed work using story points, ideal days, or other estimation units.
- Distinguish between “committed” vs. “completed” work when determining velocity.
- Analyze historical velocity trends across iterations/sprints to spot patterns, risks, and improvement opportunities.
- Use velocity to forecast how many backlog items or story points your team can realistically complete in upcoming sprints or Program Increments.
- Apply velocity in release planning and roadmap discussions to build more reliable delivery plans.
- Communicate velocity to stakeholders in a clear, non-technical way without turning it into a performance KPI or “speed” competition.
- Recognize anti-patterns, such as gaming the metric or frequently changing team composition, that make velocity unreliable.

This lesson uses lightweight, practical examples with common Agile tools. You’ll see how velocity data typically appears on a Scrum board and in reports such as burndown/burnup charts and Jira®-style velocity charts. While you don’t need to be an expert in any specific tool, the concepts will map directly to tools like Jira®, Azure DevOps, or similar Agile lifecycle management platforms, so you can immediately apply what you learn in your own environment.

The content is designed for:

- New and aspiring project managers moving into Agile, Scrum, or SAFe® roles.
- Scrum Masters and Agile team leads who want to improve planning accuracy using real team data.
- Product Owners and Business Analysts who need better forecasting for stakeholders and release planning.
- Traditional project managers transitioning from waterfall who are learning how to plan with story points and velocity instead of fixed scope and Gantt charts.
- Any team member (developer, tester, designer, etc.) who participates in estimation and wants to understand how their estimates feed into team planning.

No advanced math or prior experience with metrics is required—this lesson walks through velocity step by step, using clear examples that you can adapt immediately to your own Agile teams.

In this hands-on practice activity, learners apply the concept of team velocity to realistic Agile scenarios, moving beyond theory into the practical skills needed to plan and forecast work with confidence. By the end of the lesson, learners will be able to calculate a team’s velocity using completed story points, interpret trends over multiple iterations, and use those velocity insights to create more reliable sprint and release forecasts. They will also learn how to distinguish between healthy and unhealthy velocity patterns, adjust for changes in team composition, and avoid common anti-patterns such as “gaming” velocity or treating it as an individual performance metric.

The activity walks through examples using digital spreadsheets and, where relevant, basic Agile board tools (such as Jira-style boards) to illustrate how velocity is tracked, visualized, and iteratively improved. Learners see how simple charts, cumulative story point data, and sprint reports can feed into capacity planning and support data-driven discussions during sprint planning and retrospectives. No advanced technical setup is required; standard spreadsheet tools and typical Agile tracking boards are sufficient to complete the exercises.

This lesson is designed for new and aspiring project managers, Scrum Masters, product owners, business analysts, team leads, and software professionals transitioning into Agile roles who want to become confident in using velocity as a planning and communication tool. It is equally valuable for experienced managers from traditional project environments who need a concrete, practice-oriented bridge into Agile estimation and planning, and for any team member seeking to better understand how their day-to-day work translates into predictable delivery outcomes.

In this lesson, you’ll break down exactly how effort, complexity, and uncertainty are estimated in agile projects so you can plan work realistically and keep your teams predictable without sacrificing flexibility. By the end, you’ll be able to explain and apply core estimation techniques such as story points, relative sizing, T-shirt sizing, ideal hours, and affinity estimation. You’ll practice how to run estimation sessions with your team, guide them toward consensus using approaches like Planning Poker, and translate those estimates into sprint scope, release forecasts, and roadmap discussions with stakeholders.

You’ll also learn how to connect estimation with agile metrics such as velocity, throughput, and cycle time, so you can move from “guessing” to empirically grounded planning. The lesson walks through how to refine user stories to make them estimable, how to spot and split “epic” work items, and how to handle uncertainty, spikes, and technical debt in your estimates. You’ll leave with a clear, repeatable process for estimating new work, adjusting estimates based on real delivery data, and communicating estimation assumptions and risks to non-technical audiences.

This lesson uses Jira® as the primary tool example. You’ll see how estimation fields (story points, original estimate, time remaining) are configured and used in Jira boards, how estimation impacts Jira reports and charts, and how Scrum and Kanban teams can adopt different estimation practices within the tool. While the concepts are tool-agnostic, all demonstrations reference Jira so you can directly apply what you learn in a real project environment.

The lesson is intended for project managers, Scrum Masters, agile coaches, product owners, team leads, business analysts, and anyone transitioning from traditional project management to agile ways of working. It’s also valuable for software developers, QA engineers, and cross‑functional team members who participate in planning and want a deeper understanding of how estimation informs sprint and release planning, stakeholder expectations, and overall delivery predictability.

In this lesson, you’ll discover why agile teams rely on relative estimation instead of traditional hour-based estimating, and how this approach leads to faster, more reliable forecasting. By the end, you’ll understand the psychology and math behind relative estimation and be able to confidently explain and defend it to stakeholders, leaders, and team members who are skeptical of story points or t‑shirt sizes.

You will learn how to:
- Distinguish between absolute and relative estimation and explain why absolute time estimates (hours/days) break down in complex project work.
- Use comparative thinking (e.g., “bigger/smaller than,” “more/less complex than”) to estimate backlog items quickly and consistently.
- Apply common relative estimation scales such as story points, t‑shirt sizes (S/M/L/XL), and Fibonacci sequences.
- Connect relative estimates to practical planning activities like sprint planning, release planning, and forecasting delivery dates.
- Identify and reduce common biases in estimation, including anchoring, overconfidence, and hidden work.
- Facilitate team-based estimation conversations that improve shared understanding, not just numbers.
- Use relative estimates to track team velocity and improve predictability, without turning metrics into a weapon against the team.

This lesson introduces agile estimation concepts that are tool-agnostic, but examples and scenarios are aligned with how agile teams typically work in Jira and other backlog tools. You’ll see how relative estimation seamlessly fits into tools where you manage product backlogs, sprints, and velocity charts, so you can immediately apply these practices in your own environment regardless of the specific platform you use.

The lesson is designed for:
- Current and aspiring project managers who need to plan, forecast, and communicate delivery expectations on agile initiatives.
- Scrum Masters and Agile Team Facilitators who guide estimation sessions and want a clear, compelling way to explain relative estimation.
- Product Owners and Business Analysts responsible for prioritizing and sizing work in a product backlog.
- Team leads, engineers, QA, designers, and other delivery team members who participate in estimation but are frustrated with traditional “hour guessing.”
- Program and portfolio managers, including those working in scaled environments, who need a foundation in relative estimation to interpret velocity and make release-level decisions.

In this lesson, you’ll master two of the most practical agile estimation techniques: T‑shirt sizing and the Fibonacci sequence. By the end of the lecture, you’ll be able to confidently estimate work in an agile environment without getting stuck in debates over hours and perfect accuracy. You’ll understand when to use each method, how to run estimation sessions with your team, and how to turn abstract sizes into actionable plans for sprints and releases.

You’ll walk through step‑by‑step examples of how to estimate user stories using T‑shirt sizes (XS, S, M, L, XL) and how those sizes map to relative effort and complexity. You’ll also learn how the Fibonacci sequence (1, 2, 3, 5, 8, 13, …) simplifies story point estimation, reduces arguing over details, and helps teams converge on a shared understanding of work. Along the way, you’ll see how these estimates feed into backlog refinement, sprint planning, and forecasting delivery timelines.

To keep things lightweight and practical, the lesson focuses on techniques rather than tools. You’ll see how to apply T‑shirt sizing and Fibonacci‑based estimates using simple, accessible options such as physical cards, digital whiteboards, or basic spreadsheets, so that the same approach can be used later in tools like Jira, Azure DevOps, Trello, or any agile project management platform your team prefers.

This lesson is designed for project managers, scrum masters, product owners, team leads, business analysts, and aspiring agile practitioners who want a clear, no‑nonsense way to estimate work with cross‑functional teams. It’s also ideal for traditional project managers transitioning into agile and anyone preparing for agile, Scrum, or SAFe‑oriented roles who needs a solid, practical understanding of estimation techniques they can apply immediately with their teams.

In this lesson, you’ll move beyond theory and actually learn how to run Planning Poker estimation sessions that engage your team and produce realistic effort estimates. By the end, you’ll be able to explain the purpose of Planning Poker, set it up correctly, and facilitate it confidently with your own agile team.

You’ll learn how to:

- Explain why Planning Poker is used in agile estimation and when to apply it in your Scrum or SAFe events (e.g., backlog refinement, PI planning).
- Use story points, Fibonacci (or similar) sequences, and relative sizing to estimate work collaboratively.
- Prepare a user story backlog for Planning Poker, including defining acceptance criteria and clarifying assumptions.
- Facilitate a complete Planning Poker round: present the story, answer questions, have participants pick cards, reveal and discuss differences, then converge on a final estimate.
- Handle disagreements, outliers, and silent team members using practical facilitation techniques.
- Avoid common pitfalls such as anchoring, rushing estimates, or letting senior voices dominate the conversation.
- Integrate the output of Planning Poker into your sprint planning in Jira and your broader agile planning activities (velocity, capacity, and release forecasting).

This lesson focuses on both physical and digital implementations of Planning Poker. You’ll see how Planning Poker works with:

- Physical Planning Poker card decks (for co-located teams).
- Digital Planning Poker / estimation tools commonly used with distributed teams (examples and patterns you can apply to almost any tool).
- Jira (conceptually) for managing user stories, storing agreed story point estimates, and linking estimation results to planning boards and reports.

The lesson is ideal for:

- New and aspiring Project Managers, Scrum Masters, and Product Owners who want a clear, practical method for team-based estimation.
- Practicing agile and Scrum professionals who know the basics of story points but struggle to get consistent, high-quality estimates from their teams.
- SAFe practitioners involved in PI Planning or ART-level estimation who want a structured, collaborative technique they can use across multiple teams.
- Team leads, business analysts, and software engineers who participate in backlog refinement and want a voice in shaping realistic plans.

By the end of this session, you’ll be ready to host your own Planning Poker session—whether your team is in the same room or spread across time zones—and turn estimation into a focused, engaging team activity rather than a painful guessing game.

In this lesson, learners are introduced to the core mindset, language, and flow of Scrum so they can confidently participate in and facilitate Scrum activities in real projects. By the end of the lecture, they will be able to explain what Scrum is, why it is used, and how it fits within modern Agile project management. They will clearly distinguish roles such as Product Owner, Scrum Master, and Development Team, and describe how these roles collaborate to deliver value iteratively and incrementally. Learners will also understand key Scrum events—Sprint Planning, Daily Scrum, Sprint Review, and Sprint Retrospective—and be able to outline a basic Sprint from start to finish, including how work is selected, executed, inspected, and improved. In addition, they will be able to identify and define core Scrum artifacts like the Product Backlog, Sprint Backlog, and Increment, and articulate how these artifacts support transparency, inspection, and adaptation in a collaborative team environment.

This introductory Scrum lecture focuses on concepts and practical understanding rather than deep tool usage. However, it connects the Scrum framework to how it is commonly implemented with digital tools, using Jira® as a reference point. Learners will see how Scrum concepts such as backlogs, user stories, and sprints translate into the typical interface and workflow of Agile project management platforms. This conceptual grounding makes it easier to later configure boards, track stories, and visualize team progress in Jira® or similar tools, without overwhelming those who are new to Scrum.

The lesson is designed for project managers, Scrum Masters, Product Owners, business analysts, team leads, and aspiring Agile practitioners who want a clear, practical entry point into Scrum. It is equally suitable for software and non-software professionals—such as operations, marketing, HR, and product teams—who are moving from traditional project management into Agile ways of working. Newcomers to Scrum gain a structured foundation, while those with some experience but no formal training will solidify their understanding of terminology, roles, and events so they can participate more effectively in Scrum teams.

In this lesson on *The Three Pillars of Scrum*, you’ll build a solid, practical understanding of how transparency, inspection, and adaptation work together to make Scrum effective in real projects—not just in theory.

By the end of this lesson, you will be able to:
- Clearly explain each of the three Scrum pillars—transparency, inspection, and adaptation—and why they are essential for successful Agile delivery.
- Identify where each pillar shows up in day-to-day Scrum events such as Daily Scrum, Sprint Planning, Sprint Review, and Sprint Retrospective.
- Evaluate your team’s current practices and spot where a lack of transparency, weak inspection, or poor adaptation may be causing delays, rework, or misalignment.
- Apply concrete techniques to increase transparency (e.g., better use of boards, clearer Definition of Done, visible metrics), improve inspection (e.g., structured reviews, focused stand-ups), and strengthen adaptation (e.g., actionable retrospectives, sprint goal adjustments).
- Use the three pillars as a diagnostic lens for resolving common Scrum challenges such as unclear priorities, lack of stakeholder engagement, and hidden technical debt.
- Communicate the value of the three pillars to stakeholders and leadership, helping them understand why certain Scrum practices are non‑negotiable for predictable, high-quality delivery.

Tools and technologies included:
- Jira® (or similar Agile project management tools) is used conceptually to illustrate how to enhance transparency and inspection via boards, backlogs, and reporting.
- Digital or physical task boards, burndown charts, and dashboards are referenced as practical mechanisms to reinforce the three pillars in everyday Scrum work.

Intended audience:
- New and aspiring Scrum Masters who want a clear, actionable grasp of the core principles that make Scrum work in practice.
- Project managers transitioning from traditional (Waterfall) approaches to Agile and needing a solid foundation for leading Scrum teams.
- Product Owners seeking to better understand how to leverage the three pillars to align stakeholders and maximize product value.
- Team leads, business analysts, and developers working in Agile environments who want to improve collaboration, transparency, and continuous improvement.
- Anyone preparing for Agile or Scrum-related certifications who needs a strong conceptual and practical understanding of the three Scrum pillars.

In this lesson, you’ll unpack the real-world advantages and disadvantages of using Scrum so you can decide when, where, and how to apply it effectively in your projects. By the end, you’ll be able to clearly articulate the key benefits of Scrum—such as faster feedback loops, improved collaboration, greater transparency, and the ability to adapt quickly to changing requirements—and link each benefit to practical project outcomes like reduced risk, higher quality, and better stakeholder engagement. You’ll also be able to identify common limitations and pitfalls of Scrum, including team dependency, the need for disciplined participation, challenges with fixed scope/fixed date contracts, and the risk of misusing Scrum in unsuitable environments (e.g., highly regulated, low-change contexts).

You will learn to assess whether Scrum is the right fit for your project, team, or organization by applying a simple decision framework that compares Scrum to traditional project management approaches and to other Agile methods. You’ll be able to explain how Scrum’s advantages align with agile at scale frameworks such as SAFe® and when hybrid approaches (Scrum combined with traditional planning) might be more appropriate. Finally, you’ll gain the vocabulary and arguments needed to communicate Scrum’s trade-offs to stakeholders, executives, and team members, helping you influence methodology choices with confidence instead of relying on buzzwords or trends.

This lesson is concept-focused and does not require you to use specific software during the lecture. However, examples will reference how Scrum’s strengths and weaknesses show up in tools commonly used in agile environments, such as Jira® (for managing product backlogs, sprints, and transparency) and digital boards (Kanban-style task boards) so you can connect theory to what you see in your day-to-day tools. These references will help you understand how tooling can amplify both the benefits and the challenges of Scrum in practice.

The content is designed for new and aspiring project managers, Scrum Masters, product owners, team leads, business analysts, and professionals transitioning from traditional project management who want a balanced, honest view of Scrum—beyond the “Scrum solves everything” myth. It’s also suitable for experienced practitioners who have used Scrum informally and now want a clearer understanding of where Scrum truly shines, where it struggles, and how to explain those nuances to colleagues, leaders, or clients.

In this lesson, you’ll gain a clear, practical understanding of what an effective Product Owner does day-to-day in a Scrum environment—and how that role fits into modern project management approaches like Agile, Scrum, SAFe®, and Jira®. By the end, you’ll be able to confidently explain the Product Owner’s responsibilities, collaborate more effectively with Scrum Masters and development teams, and apply Product Owner best practices on your own projects.

You’ll learn how the Product Owner owns and shapes the product vision, translates that vision into a clear, value-driven Product Backlog, and continuously refines and prioritizes backlog items to maximize business value. You’ll see how they work with stakeholders to gather and clarify requirements, convert them into user stories with well-defined acceptance criteria, and ensure those stories are ready for implementation in upcoming sprints. We’ll walk through how Product Owners make trade-off decisions based on value, risk, dependencies, and team capacity, and how they use sprint reviews and customer feedback loops to guide incremental delivery.

You’ll also learn what “good” engagement looks like from a Product Owner in key Scrum events: planning, daily Scrum (as an observer and collaborator, not a manager), sprint review, and backlog refinement. We’ll clarify what the Product Owner *should* do—owning the “what” and “why” of the product—and what they should avoid doing, such as micro-managing the “how” of technical implementation. The lesson also covers how the Product Owner role scales in larger organizations, including how it connects with Product Managers, Business Owners, and Release Train Engineers in SAFe® environments.

This lesson introduces Jira® at a conceptual level to show how a Product Owner can manage a real-world backlog. You’ll see how Jira® is used to capture user stories, track priorities, visualize the status of work, and communicate the product roadmap to stakeholders and the development team. While it’s not a step-by-step Jira® tutorial, you’ll come away understanding how Product Owners typically use the tool to support backlog management, sprint planning, and ongoing transparency.

The lesson is designed for aspiring and practicing Product Owners, Scrum Masters who want to better support their Product Owners, business analysts transitioning into Agile roles, project managers moving from traditional/waterfall to Agile and Scrum, and team leads or stakeholders who frequently interact with Product Owners and want to understand how to collaborate with them more effectively. It’s also suitable for anyone preparing for Agile or Scrum certifications who needs a clear, real-world view of what a Product Owner actually does and how the role contributes to successful product delivery.

In this lesson, you’ll get a clear, practical understanding of what Scrum Developers actually do on a day‑to‑day basis and how their work drives the success of every sprint and release. By the end of the session, you’ll be able to:

- Explain the official Scrum definition of “Developer” and how it differs from traditional job titles like programmer, tester, business analyst, or designer.
- Identify the key responsibilities of Developers across the Scrum events: refining the Product Backlog, planning and committing to Sprint Backlog items, delivering Increment(s), and contributing to Sprint Review and Retrospective.
- Describe how Developers collaborate with the Product Owner and Scrum Master and where clear ownership starts and ends for each role.
- Break down a Product Backlog item into actionable tasks, estimate effort as a team, and understand how Developers forecast what can be done in a sprint.
- Apply core agile engineering and workflow practices (pairing, code review, testing, continuous integration) in a way that supports transparency and “Done” in Scrum.
- Recognize common anti‑patterns, such as partial team commitments, “mini‑waterfalls” inside the sprint, and role silos, and propose better Scrum‑aligned behaviors.
- Participate more effectively in cross‑functional Scrum teams by understanding how Developers share accountability for quality, value, and predictability.

Throughout the lesson, you’ll see how Developer responsibilities naturally connect to agile tools used by modern project teams. We will reference Jira to illustrate how Developers:

- Select and pull work into a sprint.
- Update task status and communicate progress through the board.
- Collaborate around user stories, acceptance criteria, and Definition of Done.

While the focus is on people and practices rather than software configuration, you’ll leave with a concrete picture of how Developers’ daily activities show up in a tool like Jira in a real project environment.

This lesson is designed for:

- Current and aspiring Developers working in or moving to Scrum and agile environments (software engineers, QA engineers, DevOps, UI/UX, analysts, data engineers).
- Project managers, team leads, and Scrum Masters who need a sharper understanding of how Developers should operate in a Scrum Team.
- Product Owners and business stakeholders who want to collaborate more effectively with Developers and set realistic expectations for delivery.

No prior Scrum experience is strictly required, but a basic familiarity with agile concepts or software delivery will help you get the most value from this lecture.

In this lesson, you’ll gain a clear, practical understanding of what a Scrum Master actually does day to day and how this role differs from a traditional project manager. By the end, you’ll be able to explain the responsibilities of the Scrum Master across the entire Scrum framework, from sprint planning through daily standups, reviews, and retrospectives. You’ll learn how to act as a servant leader, coach, and facilitator for your team, and how to remove impediments so that developers can focus on delivering value. You’ll also see how the Scrum Master supports Product Owners, protects the team from scope creep, and encourages a culture of continuous improvement. After this lesson, you’ll be equipped to step into the Scrum Master role more confidently, communicate your value to stakeholders, and apply these practices in real-world agile environments.

The lesson uses real-world examples and references practical collaboration and tracking tools commonly used with Scrum, such as Jira for managing backlogs and sprint boards, as well as virtual whiteboards and communication platforms to support agile ceremonies. While you don’t need to be an expert with these technologies to benefit from the lesson, you’ll see how a Scrum Master typically leverages them to facilitate transparency, inspect progress, and adapt plans.

This lesson is designed for project managers transitioning into agile roles, aspiring or new Scrum Masters who want clarity on what is expected of them, Product Owners who need to understand how best to collaborate with a Scrum Master, team leads and development team members working in agile teams, and professionals preparing for Scrum or agile-related certifications. It’s also highly relevant for managers and stakeholders in organizations adopting agile methods who need to understand how the Scrum Master role contributes to team performance and successful delivery.

In this lesson, you’ll get a clear, end-to-end understanding of how Scrum events fit together to create a predictable rhythm for delivery and collaboration. By the end of the session, you’ll be able to:

- Explain the purpose and flow of each Scrum event: Sprint Planning, Daily Scrum, Sprint Review, and Sprint Retrospective.
- Describe how these events support transparency, inspection, and adaptation within the Scrum framework.
- Map each event to the roles involved (Product Owner, Scrum Master, Developers, stakeholders) and understand who does what, when, and why.
- Visualize how Scrum events structure a full Sprint lifecycle and how work moves from planning to delivery and continuous improvement.
- Identify common anti-patterns (e.g., status-update Daily Scrums, rushed Retrospectives) and recognize what “good” looks like for each event.
- Confidently participate in or facilitate basic Scrum events in your own team or organization.

This lesson is primarily conceptual and framework-focused. It does not require advanced tools or coding technologies. References may be made to digital boards and project tracking tools (such as Jira or similar platforms) to illustrate how Scrum events are supported in practice, but the emphasis is on understanding the events themselves rather than on tool configurations or step-by-step software usage.

The content is designed for:

- Current and aspiring project managers transitioning into Agile and Scrum environments.
- Scrum Masters, Product Owners, and team leads seeking a structured overview of key Scrum ceremonies.
- Business analysts, product managers, and stakeholders who regularly interact with Agile teams and need to understand the cadence and purpose of Scrum events.
- Professionals from traditional project management or waterfall backgrounds who want a clear, practical introduction to how Scrum teams plan, inspect progress, and improve every Sprint.

In this lesson, learners gain a crystal-clear understanding of what a Sprint is in Scrum and how it functions as the core engine of agile delivery. By the end, they will be able to define a Sprint in practical terms, explain its purpose within the Scrum framework, and describe how it connects to the product backlog, Sprint planning, and the overall Agile project lifecycle. Learners will be equipped to outline the key characteristics of a Sprint—timeboxing, predictability, and a potentially shippable Increment—and will be able to distinguish an effective Sprint from a poorly structured one.

They will also develop the skills to structure and manage a Sprint from start to finish: setting a realistic Sprint Goal, determining what work fits into the Sprint, and understanding how to keep the Sprint focused and protected from uncontrolled scope changes. The lesson clarifies roles and responsibilities of the Product Owner, Scrum Master, and Developers throughout the Sprint, enabling learners to support their teams in delivering consistent value every iteration. By the end, learners will be confident in explaining the flow of work within a Sprint and will be ready to participate in, or lead, Sprints in a real-world agile environment.

The lesson primarily focuses on the Scrum framework and Sprint mechanics, with conceptual references to Agile project tools. While it does not require learners to use a specific software during the lesson, it provides examples of how Sprints are represented and managed in digital tools such as Jira, including Sprint backlogs, boards, and basic tracking concepts. This prepares learners to translate theory into practice when they later work with agile project management tools.

This lesson is designed for new and aspiring project managers, Scrum Masters, Product Owners, team leads, business analysts, and software or product development team members who are transitioning into agile and Scrum ways of working. It also serves professionals in traditional project roles who want to understand how Sprints differ from phases or milestones in predictive project management, as well as anyone preparing for agile or Scrum-related certifications who needs a clear and practical grounding in Sprint fundamentals.

In this lesson, you’ll learn how to plan a sprint from end to end so your team starts each iteration with clarity, confidence, and a realistic path to delivering value. You’ll walk through how to translate the product backlog into a focused sprint goal, break down work into well‑defined sprint backlog items, and estimate effort using techniques such as story points and capacity planning. By the end, you’ll be able to facilitate or actively contribute to a sprint planning session, negotiate scope with stakeholders, and create a sprint plan that balances ambition with what the team can reliably deliver.

You’ll practice how to identify and prioritize the right items for the sprint, slice large requirements into smaller increments, and ensure each item has clear acceptance criteria. The lesson also covers how to use velocity to forecast the team’s likely throughput, how to avoid overcommitting, and how to handle dependencies and risks before the sprint starts. You’ll see how to turn planning outcomes into a visual, trackable plan and how to set up your team for effective daily collaboration throughout the sprint.

This lesson uses Jira as the primary tool to demonstrate sprint planning in a real-world context. You’ll see how to refine and prioritize backlog items in Jira, create and configure a new sprint, move issues into the sprint backlog, set and track the sprint goal, and confirm that the team’s capacity aligns with the selected work. You’ll also learn how Jira boards, filters, and basic reporting support informed decisions during sprint planning and throughout the sprint.

This lesson is designed for new and aspiring project managers moving into agile roles, Scrum Masters who want a more structured approach to sprint planning, product owners responsible for selecting and shaping sprint work, and team leads or business analysts who participate in planning sessions. It is equally valuable for traditional project managers transitioning from waterfall to agile ways of working, as well as developers, QA engineers, and other team members who want to better understand how a well-planned sprint sets them up for successful delivery.

In this lesson, you’ll gain a practical, end‑to‑end understanding of the Daily Scrum—what it is, why it exists, and how to run it so it actually helps your team deliver. By the end of the session, you’ll be able to clearly explain the purpose of the Daily Scrum, distinguish it from a status meeting, and confidently facilitate or participate in a time‑boxed 15‑minute event that keeps the team aligned on the Sprint Goal.

You’ll learn how to structure the conversation so it focuses on progress toward the Sprint Goal, not on individual reporting. We’ll walk through what effective Daily Scrum questions and formats look like today (including modern alternatives to the old “three questions” pattern) and how to adapt the event for co‑located, hybrid, and fully remote Scrum Teams. You’ll see how to identify and remove common anti‑patterns such as turning the meeting into a detailed problem‑solving session, reporting to the Scrum Master or manager, or allowing the conversation to drift off-topic.

You’ll also practice how to use the Daily Scrum to proactively uncover blockers, coordinate handoffs, and adjust the Sprint plan when reality changes. After this lesson, you’ll be able to:
- Facilitate or contribute to a concise, outcome‑oriented Daily Scrum.
- Keep the conversation focused on the Sprint Goal instead of individual task lists.
- Spot and correct behaviors that undermine the event’s value.
- Use insights from the Daily Scrum to drive follow‑up conversations, re‑prioritize work, and improve team flow.

This lesson references common agile tooling such as digital Scrum boards and issue trackers. You’ll see how Daily Scrums connect to tools like Jira® for visualizing work in progress, updating task status, and making blockers visible to the whole team. While no advanced configuration is required, you’ll understand where and how the Daily Scrum fits into the broader tool ecosystem used to manage agile work.

The content is designed for current and aspiring Scrum Masters, project and program managers moving into agile ways of working, Product Owners who want more effective collaboration with their teams, and team members (developers, testers, analysts, designers, DevOps engineers) who participate in Scrum events and want to make them more valuable. It’s also suitable for leaders and stakeholders who need a clear, practical view of how this daily event supports transparency, inspection, and adaptation in agile delivery.

By the end of this lesson, learners will be able to confidently plan, facilitate, and follow up on an effective Sprint Review that truly showcases product value and drives meaningful stakeholder collaboration. You will learn how to structure the event from start to finish, including preparing the agenda, selecting what to demonstrate from the Increment, and clearly linking completed work to Sprint Goals and the Product Goal. The lesson walks through how to guide stakeholders through the review, encourage constructive feedback, and turn that feedback into actionable updates to the Product Backlog. You will also understand how the Sprint Review fits into the overall Scrum events flow, how it differs from a demo or a status meeting, and how to avoid common anti‑patterns such as turning the event into a one-way presentation or a blame session about unfinished work.

You will practice framing outcomes instead of outputs, using metrics and simple visuals to illustrate progress and value delivery. The session also covers techniques for managing time, handling difficult questions from stakeholders, and keeping the conversation focused on product direction rather than detailed task discussions. By the end, you’ll be able to create a repeatable Sprint Review format that increases transparency, supports empirical decision making, and strengthens trust between the Scrum Team and stakeholders.

This lesson uses practical examples based on typical tooling used in agile environments, with a focus on using Jira to prepare for the Sprint Review. You will see how to identify completed Product Backlog Items, visualize the Increment, and create simple views or dashboards that make it easy to walk stakeholders through what has been delivered. While the underlying principles are tool-agnostic, the walkthroughs and examples reference Jira boards, filters, and reports to illustrate how to support your Sprint Review preparation and facilitation in a real-world setting.

The lesson is intended for current and aspiring project managers, Scrum Masters, Product Owners, team leads, business analysts, and anyone working within Agile, Scrum, or scaled frameworks who needs to present progress to stakeholders on a regular basis. It is also valuable for stakeholders and managers who attend Sprint Reviews and want to better understand how the event should run so they can contribute more effectively. Whether you are new to agile delivery or looking to improve existing ceremonies, this lesson provides clear, practical guidance you can apply immediately with your team.

In this lesson, you’ll learn how to run highly effective Sprint Retrospectives that actually lead to continuous improvement instead of repetitive complaints. By the end, you’ll be able to confidently facilitate retrospectives that uncover root causes, generate actionable improvements, and strengthen collaboration and trust across your Scrum Team. You’ll know how to structure the event, ask powerful questions, handle difficult conversations, and turn insights into realistic changes that can be implemented in the very next sprint. You’ll also be able to measure whether your retrospectives are working by tracking concrete improvement outcomes over time.

You’ll see how digital collaboration tools such as Jira® and common online whiteboarding or polling tools (examples are referenced conceptually, not taught as software tutorials) can be used to gather data for retrospectives, visualize patterns in sprint performance, and log improvement actions as trackable work items. You’ll understand how to integrate retro outcomes into your backlog and sprint planning so that process improvements become part of your normal workflow rather than “extra” work.

This lesson is ideal for new and aspiring Scrum Masters, project managers transitioning from traditional methods, product owners who want more value from team events, team leads and delivery managers working in agile or hybrid environments, and developers or testers who participate in Scrum ceremonies and want a clear, structured way to make their team’s work experience and outcomes better from sprint to sprint.

In this lesson, learners explore the foundational Scrum artifacts and how they work together to enable transparent, value-driven delivery in Agile projects. By the end, learners will be able to clearly distinguish the purpose, content, and ownership of the Product Backlog, Sprint Backlog, and Increment, and explain how these artifacts support inspection and adaptation in Scrum events. They will understand how well‑managed artifacts lead directly to better prioritization, predictable delivery, and more valuable outcomes for stakeholders.

Learners will be equipped to describe how Product Goals, Sprint Goals, and the Definition of Done connect to the core artifacts and guide team behavior. They will also be able to identify common anti‑patterns—such as outdated backlogs or unclear definitions of done—and articulate how to improve artifact quality to enhance transparency and team alignment. This lesson lays the conceptual groundwork needed before diving into practical implementation in tools or scaling frameworks.

The lecture is conceptual and process‑oriented, focusing on Scrum theory rather than specific software. Any references to tools (such as Jira boards or Agile project tracking systems) are illustrative, not hands‑on; the core aim is to understand the artifacts themselves so that learners can apply this knowledge regardless of which platform their organization uses.

This lesson is designed for new and aspiring project managers, Scrum Masters, Product Owners, and team leads who are transitioning to Agile ways of working, as well as experienced project professionals from traditional (waterfall) backgrounds who need a clear and structured introduction to Scrum artifacts. It is also suitable for business analysts, product managers, and stakeholders who interact with Agile teams and want to understand how work is captured, planned, and turned into increments of value in a Scrum environment.

In this lesson, you’ll gain a practical, end‑to‑end understanding of how to build, refine, and maintain a high‑impact product backlog that consistently delivers value in Agile and Scrum environments. By the end, you’ll be able to clearly distinguish between a product backlog and a sprint backlog, write effective user stories with clear acceptance criteria, and apply prioritization techniques so your team always works on the most valuable items first. You’ll also learn how to slice large initiatives (epics) into smaller, testable backlog items, estimate effort with story points, and prepare a backlog that is genuinely “ready” for sprint planning. This includes understanding how to keep the backlog transparent, ordered, and aligned with the product vision and roadmap, and how to use backlog refinement sessions to reduce ambiguity and surprises during sprints.

You’ll see how widely used tools such as Jira are applied to manage the product backlog in real projects. The lesson walks through how a backlog is represented in Jira boards, how to create and update backlog items, link them to epics, add acceptance criteria and estimates, and use fields, filters, and views to support prioritization and stakeholder visibility. While the focus is on concepts and best practices, the examples are shown in the context of practical configurations that Agile teams often use in Jira.

This lesson is designed for new and aspiring project managers, Scrum Masters, and Product Owners who want to strengthen their backlog management skills, as well as business analysts, team leads, and developers who participate in backlog refinement and sprint planning. It is also valuable for traditional project managers transitioning into Agile roles and for anyone preparing for Agile or Scrum‑related certifications who needs a clear, actionable understanding of how a well‑managed product backlog drives predictable delivery and real customer value.

In this lesson on **Building and Managing the Sprint Backlog**, learners will master how to turn high-level product backlog items into a clear, actionable sprint plan that the Scrum Team can actually deliver. By the end of the lesson, they will be able to:

- Translate product backlog items into well-defined sprint backlog tasks with clear acceptance criteria.
- Break down user stories into technical and functional tasks that can be estimated and owned by team members.
- Apply effective sprint planning techniques to ensure the sprint backlog reflects realistic team capacity.
- Maintain and update the sprint backlog throughout the sprint as work progresses and new information emerges.
- Use the sprint backlog as a living artifact to track progress, manage scope changes, and support daily Scrum discussions.
- Distinguish between a good sprint backlog (transparent, prioritized, testable, estimable) and a weak one (vague, overstuffed, not linked to a sprint goal).
- Connect the sprint backlog to the sprint goal so that every task clearly contributes to business value.
- Manage dependencies, blockers, and risks within the sprint backlog to keep delivery on track.
- Use simple metrics (remaining work, burn-down views, flow of tasks) to inspect and adapt during the sprint.

This lesson includes practical demonstrations and examples using **Jira** as the primary Agile project management tool. Learners will see how to:

- Create and configure a sprint backlog in Jira boards.
- Break down and link sub-tasks to user stories in Jira.
- Update task status and use board columns to visualize workflow.
- Use Jira filters and views to monitor sprint progress and identify bottlenecks.

The lesson is designed for:

- New and aspiring project managers transitioning into Agile environments who need a clear, hands-on understanding of how a sprint backlog actually works in day-to-day practice.
- Scrum Masters who want to strengthen their facilitation of sprint planning and daily Scrum using a well-managed sprint backlog.
- Product Owners who need to collaborate effectively with the team to ensure the sprint backlog reflects business priorities and the sprint goal.
- Team leads, business analysts, and developers working in Scrum or hybrid Agile settings who want to better understand how their tasks fit into the overall sprint plan.
- Professionals preparing for Agile or Scrum-related certifications who want a practical, tools-based understanding of sprint backlog management rather than just theory.

In this lesson on delivering value with increments, learners dive deep into how Scrum teams transform Product Backlog items into tangible, inspectable value at the end of each Sprint. By the end of the lecture, they will be able to clearly distinguish between a “potentially releasable” Increment and a merely “completed” set of tasks, and explain why this distinction is critical for stakeholder trust and business outcomes. Learners will also be able to articulate and apply the Definition of Done to ensure that every Increment meets agreed quality standards, supports transparency, and can be shipped without additional hidden work.

Participants will learn how to slice work so that each Increment is small, testable, and value-focused rather than just activity-focused. They will be able to map Product Backlog items to concrete Sprint Goals and demonstrate how each Increment contributes to those goals and to the overall product vision. Through practical examples, learners will understand how increments accumulate over time to form a coherent product, and how to avoid common anti-patterns like “partially done work,” “demo-driven development,” and “big bang releases.”

The lesson also covers how to leverage collaboration tools to make Increments visible and inspectable to the whole Scrum Team and stakeholders. While the focus remains on core Scrum concepts rather than tool mechanics, learners will see how agile work-management platforms such as Jira® can be used to track incremental progress, visualize what is truly “Done,” and prepare Increments for Sprint Review. This includes using boards, status workflows, and simple reporting to make each Increment transparent and to support empirical decision-making.

This lecture is designed for aspiring and current project managers, Scrum Masters, Product Owners, team leads, and delivery managers who want to move beyond process theory and focus on real value delivery. It is also well-suited for business analysts, software developers, QA engineers, and agile practitioners who participate in Scrum events and want a clearer understanding of what should exist at the end of each Sprint. Leaders and stakeholders who rely on Scrum teams for predictable, high-quality delivery will also benefit from understanding Increments, so they can better interpret progress, inspect outcomes, and make informed release decisions.

In this beginner-friendly lesson, you’ll build a solid, practical understanding of Kanban and how to use it to visualize and improve the flow of work on any project. By the end of the lecture, you’ll be able to clearly explain what Kanban is, when to use it instead of—or alongside—Scrum, and how it fits into modern Agile project management. You’ll walk away knowing how to design a simple Kanban system from scratch, including defining workflow stages, setting up columns, and using work‑in‑progress (WIP) limits to reduce bottlenecks and multitasking overload.

You will learn how to read and interpret a Kanban board so you can quickly see where work is stuck, where the team is overloaded, and where you can improve flow. You’ll be able to create and manage basic Kanban boards (physical or digital), prioritize work in a pull-based system, and track key flow metrics such as cycle time and throughput at an introductory level. The lesson also gives you a clear vocabulary: cards, columns, swimlanes, classes of service, WIP limits, lead time vs. cycle time, and what “flow” really means in day‑to‑day project work.

To keep things practical and actionable, the lesson uses examples drawn from common Kanban tools and digital boards. You’ll see how Kanban concepts map onto popular project management platforms such as Jira and Trello-style boards, so you can recognize Kanban features in tools you may already be using. Even if you don’t have access to any specific software, you’ll be able to apply the same principles with a whiteboard, sticky notes, or simple spreadsheets.

This lesson is designed for new and aspiring project managers, Scrum Masters, Agile team members, business analysts, product owners, and team leads who want a clear, non‑technical introduction to Kanban. It’s equally useful for professionals working in software development, IT, operations, marketing, HR, or any knowledge‑work environment where tasks flow through a series of steps. No prior Kanban experience is required—if you understand basic project work and tasks, you’ll be able to follow along and immediately start visualizing and optimizing the flow of your own work.

In this lesson, you’ll move from theory to practice by learning how to design and use a Kanban board to make work visible, expose bottlenecks, and improve delivery flow. By the end, you’ll be able to confidently identify the essential columns of a Kanban workflow, distinguish between task granularity levels (epics, stories, tasks, sub-tasks), and map them onto a board in a way that makes sense for your team. You’ll know how to define clear “Start” and “Finish” criteria for each column, apply Work-In-Progress (WIP) limits, and interpret what your board is telling you about cycle time, blockers, and handoff issues. You’ll also be able to redesign an overloaded or confusing board into a simple, intuitive system that supports continuous improvement instead of chaos.

You will see Kanban concepts demonstrated using digital board tools such as Jira Software’s Kanban boards and Trello-style visual boards. The focus is on features that matter for flow management: configuring columns and swimlanes, setting WIP limits, using labels and filters to slice work by type or priority, and tracking blocked items. You’ll also see the pros and cons of physical whiteboard-and-sticky-note setups, and how to transition from physical to digital when teams are hybrid or fully remote. While the lecture is tool-agnostic, the examples are grounded in common real-world platforms so that you can immediately apply what you learn using your own organization’s tooling.

This lesson is designed for project managers, Scrum Masters, Agile team leads, product owners, and delivery managers who want to apply Kanban to real projects, regardless of whether they are in software, operations, marketing, or other knowledge-work domains. It’s equally suitable for professionals transitioning from traditional project management who need a clear, practical introduction to visual workflow management, as well as experienced Agile practitioners who use Scrum but want to incorporate Kanban techniques to improve transparency and flow across their teams and portfolios.

In this lesson, learners dive deep into how to read a Kanban board like a diagnostic tool rather than just a task list. By the end, they will be able to identify bottlenecks, spot waste, and recognize systemic flow issues that silently slow teams down. You will learn to interpret work-in-progress patterns, aging work items, blocked cards, and swimlane congestion so you can pinpoint where the process is breaking down. You’ll be able to detect overload, unclear policies, and unbalanced workflows and then translate those insights into concrete improvement actions such as adjusting WIP limits, redefining columns, or re-sequencing work. This lesson also develops your ability to use simple flow metrics—like throughput, cycle time, and cumulative flow—to validate whether your Kanban changes are actually improving delivery.

The lesson uses Kanban boards in modern agile project management tools to illustrate concepts. Example flows and inefficiencies are demonstrated using Jira-style boards and similar digital Kanban environments, but the principles apply equally to physical whiteboard-and-sticky-note setups as well as to other platforms that support Kanban views.

This lesson is designed for project managers, Scrum Masters, Kanban practitioners, product owners, team leads, and aspiring agile leaders who want to move beyond simply “using a board” toward actively optimizing flow. It’s equally suitable for professionals transitioning from traditional project management into lean-agile ways of working, as well as experienced agile practitioners who want sharper eyes for diagnosing hidden inefficiencies in their Kanban systems.

By the end of this lesson, learners will be able to recognize, diagnose, and systematically address underutilized resources in a Kanban system, whether those resources are people, skills, or technical assets. You’ll learn how to interpret Kanban board signals to spot idle work centers, unbalanced workloads, and “hidden waiting time” that doesn’t show up as blocked cards. You’ll be able to distinguish between healthy slack (needed to absorb variability) and true underutilization that is slowing overall flow efficiency. The lesson guides you through rebalancing work across the system using Kanban practices such as adjusting WIP limits, refining workflow policies, and restructuring swimlanes or classes of service. By the end, you’ll be able to redesign your flow so that underused capacity is redirected to high‑value work, and you’ll know how to measure the impact using flow metrics like throughput, lead time, and utilization trends.

This lesson uses practical examples drawn from physical Kanban boards and digital Kanban implementations in tools such as Jira and other online boards. You’ll see how to represent resource constraints visually on Kanban columns, how to configure WIP limits per person or per skill, and how to use basic analytics (cumulative flow diagrams and simple dashboards) to reveal and correct imbalances. The focus is on low‑friction techniques you can apply immediately with whatever Kanban tooling you already use.

The lesson is intended for project managers, delivery leads, Scrum Masters working in a Kanban or Scrumban context, team leaders, and product owners who want to get more value out of existing capacity without resorting to overtime or constant reprioritization. It is also valuable for business analysts, operations managers, and individual contributors in software, IT, marketing, product, and service teams who operate with Kanban boards and want to improve flow, balance workloads, and make better data‑informed decisions about how to allocate their time and skills.

By the end of this lesson, learners will understand how uneven and unpredictable task sizes impact Kanban flow, throughput, and cycle time, and they will be able to actively manage this variability instead of being surprised by it. You will learn how to break down large items into smaller, flow-friendly work units, recognize when decomposition is not possible or not worth the effort, and apply practical policies to keep the board moving even when some items are significantly larger than others. You will be able to set realistic Work in Progress (WIP) limits that account for different task sizes, spot when a “monster” task is blocking the system, and use swimlanes and classes of service to keep urgent or small items from being trapped behind large work items.

The lesson also covers how to read cycle time and throughput metrics in the presence of unequal tasks, so you can avoid misinterpreting data, set better service‑level expectations, and have more credible conversations with stakeholders about delivery forecasts. You will practice applying techniques such as splitting vs. spiking, aging‑work‑in‑progress analysis, and setting explicit policies for handling large or uncertain items so the team maintains a smooth, predictable flow rather than oscillating between idle time and overload.

This lecture uses a digital Kanban board tool (illustrated with Jira boards) to demonstrate how to visualize large versus small tasks, configure WIP limits, and highlight blocked or aging work items. While examples show how these concepts appear in Jira, the principles apply equally to any Kanban tool (physical boards, Trello, Azure Boards, Asana, etc.), and no prior expertise with a specific tool is required.

This lesson is intended for project managers, Scrum Masters, Agile coaches, team leads, product owners, and delivery managers who are already working with Kanban or considering introducing Kanban practices to teams that deal with a mix of small quick tasks and large complex work items. It is also valuable for business analysts, software engineers, and operations/support professionals who want to improve the predictability and flow of their work in environments where task size varies significantly.

By the end of this lesson, learners will be able to design and use a Kanban board that makes task status, bottlenecks, and priorities instantly clear to everyone on the team. You’ll learn how to choose the right columns and swimlanes, how to define unambiguous “done” criteria for each step in your workflow, and how to set up visual markers that tell you at a glance which items are blocked, urgent, at risk, or ready for the next stage. You’ll also know how to track work items from idea to completion with fewer status meetings, fewer surprises, and smoother hand‑offs across the team.

You’ll apply practical strategies for tagging and categorizing tasks so you can quickly slice the work by priority, class of service, risk, or type of work (features, bugs, technical debt, support, etc.). The lesson walks through smarter ways to use WIP limits and policies so that markings on your board actually drive behavior—preventing overloading, surfacing hidden work, and enabling you to spot flow issues early. You’ll practice turning vague to‑dos into clearly marked, trackable tasks that connect directly to value and outcomes rather than just activity.

This lesson uses Kanban boards implemented in Jira for hands‑on illustration. You’ll see how to configure issue types, labels, components, and custom fields to mirror the markings you define on your physical or digital Kanban board. We’ll explore how to set up simple automation rules to update task status, flags, or priorities, so your markings remain trustworthy without manual overhead. While examples focus on Jira, the principles are tool‑agnostic and can be applied in Trello, Asana, Azure DevOps, or any Kanban tool.

The content is intended for project managers, Scrum Masters, Agile and SAFe practitioners, product owners, team leads, and coordinators who need clearer tracking and reporting of work in progress. It’s equally useful for business analysts, QA leads, operations and support managers, and any professional working with Kanban boards who wants to move beyond basic “To Do / Doing / Done” tracking to a more intelligent, self‑explaining workflow that supports faster, more predictable delivery.

In this lesson, you’ll dive deep into the most common pitfalls and issues that teams encounter when implementing Kanban, and how to systematically prevent or fix them. By the end, you’ll be able to recognize early warning signs that a Kanban system is degrading, diagnose bottlenecks and workflow breakdowns, and apply practical countermeasures to restore smooth, predictable flow. You’ll learn how to set meaningful Work in Progress (WIP) limits, deal with constant interruptions and unplanned work, avoid turning your board into a messy “task parking lot,” and keep your Kanban practices aligned with real business priorities rather than just moving tickets across columns. You’ll also develop the skill to use metrics such as cycle time and throughput to identify underlying problems instead of relying on intuition alone.

You’ll see how Kanban boards—both digital and physical—can be misconfigured (too many columns, vague policies, no swimlanes), and you’ll learn how to redesign them to improve clarity and throughput. The session walks through practical examples of overloaded columns, hidden queues, stalled work items, and neglected blocked tickets, then shows how to redesign policies, adjust WIP limits, or rebalance team responsibilities to remove friction. You’ll also learn how to handle multi-tasking and context switching, manage dependencies between teams, and address cultural issues such as resistance to transparency or “hero culture” that undermines flow.

This lesson uses Jira Software as the primary tooling example to illustrate Kanban issues in a digital environment. You’ll see how common configuration mistakes in Jira Kanban boards—such as misaligned workflows, poorly chosen statuses, and lack of explicit policies—create invisible bottlenecks, and how to correct them. While the ideas are tool-agnostic and apply equally to other Kanban tools or physical boards, the concrete demonstrations and tips reference Jira’s Kanban board settings, columns, filters, and basic reporting views (like control charts and cumulative flow diagrams) to help you translate theory into practice in a real-world tool.

The content is designed for project managers, Scrum Masters, Product Owners, Agile and SAFe® practitioners, team leads, and coordinators who are already using or planning to use Kanban and want to move beyond the basics. It’s equally valuable for software development teams, operations/support teams, and business teams (marketing, HR, finance, etc.) who rely on visual workflow management and need to improve predictability and throughput. If you are responsible for delivery and coordination, already work with Jira or similar tools, and want to sharpen your ability to detect and resolve Kanban system failures before they impact customers, this lesson is tailored for you.

In this lesson, you explore the often-misunderstood concept of “Done” in a Kanban system and how it differs from traditional project management or even Scrum-style definitions of Done. By the end, you’ll be able to clearly define what “Done” means for your own workflow, translate that definition into practical board policies, and use it to improve predictability, quality, and flow across your team or organization.

You’ll learn how “Done” operates at multiple levels: individual cards, workflow stages, and overall delivery. The lesson walks you through creating explicit policies that clarify when work can move from one column to the next, how to define acceptance criteria that are lightweight but unambiguous, and how to avoid the trap of “almost done” work clogging the system. You’ll practice turning vague status labels like “In Review” or “Testing” into concrete, observable conditions that everyone understands in exactly the same way, which reduces rework and handoff friction.

The session also covers how to integrate the idea of “Definition of Done” with Kanban’s focus on continuous flow, rather than sprints or timeboxes. You’ll see how to align “Done” with Service Level Expectations (SLEs), classes of service, and customer-centric outcomes, and how “Done” relates to upstream and downstream activities such as discovery, deployment, and validation in production. Common pitfalls—like defining “Done” only from a technical perspective or ignoring non-functional requirements—are highlighted with examples and practical remedies you can apply immediately.

To make the concepts concrete, the lesson illustrates how a Kanban board in a digital tool (for example, Jira-style boards or similar Kanban tools) can be configured to reflect your definitions of “Done” via column policies, card templates, and checklists. You’ll see how these visual cues help teams self-manage quality, simplify status reporting, and make bottlenecks visible in real time without adding heavy documentation or governance.

This lesson is designed for project managers, product owners, Scrum Masters transitioning into flow-based practices, team leads, and delivery managers who want to tighten up how work is finished and released. It’s equally valuable for business analysts, developers, QA specialists, and operations professionals who participate in end-to-end delivery and need a shared, actionable understanding of when work is truly complete in a Kanban system.

In this lesson, learners establish the essential ground rules that make a Kanban system stable, transparent, and continuously improving. By the end, they will be able to define clear policies for how work enters, moves through, and exits the board, so that flow becomes predictable instead of chaotic. They will learn how to set up explicit “rules of engagement” for the team—covering how to pull work, how to handle blockers, defects, and expedite items, and how to respond when work-in-progress limits are breached. Learners will also know how to document these rules as simple, visible “working agreements” that everyone can understand and follow, and how to refine those agreements over time using data from the system.

The lesson walks through configuring a Kanban board using common digital tools such as Jira and Trello-style boards. Learners see how to represent policies directly on the board with column definitions, entry/exit criteria, service classes, WIP limits, and blocker tags. While the concepts are tool-agnostic, practical examples focus on how these rules are implemented in typical agile tooling used by project managers and Scrum Masters.

This content is designed for project managers, Scrum Masters, agile coaches, team leads, and product owners who want to move beyond simply “having a board” to running a disciplined flow-based system. It is also valuable for software delivery teams, operations/support teams, and business teams adopting Kanban for the first time, as well as experienced practitioners who need a structured way to formalize and improve their existing Kanban policies.

In this lesson, you’ll get a practical, grounded introduction to Extreme Programming (XP) so you can start applying its principles and practices on real software projects right away. By the end of the session, you’ll be able to:

- Explain what XP is, how it emerged, and how it fits alongside Agile, Scrum, and SAFe® in a modern delivery environment
- Identify the core XP values (communication, simplicity, feedback, courage, respect) and relate them to day‑to‑day team behavior
- Describe the main XP practices—such as pair programming, test‑driven development (TDD), continuous integration, simple design, and refactoring—and understand why they improve quality and responsiveness
- Map XP practices onto your current workflow so you can introduce them incrementally without disrupting existing Scrum or SAFe® ceremonies
- Recognize when XP is a good fit (high‑change, high‑uncertainty software work) and when a lighter touch is more appropriate
- Outline a lightweight plan for “getting started with XP” in your organization, including how to secure stakeholder support and reduce resistance from developers and managers
- Use XP concepts to improve collaboration between developers, testers, product owners, and business stakeholders, even in distributed or hybrid teams

This lesson is concept‑ and practice‑focused rather than tool‑driven. We’ll reference commonly used software development and DevOps tools at a high level—such as version control systems (e.g., Git), continuous integration servers, unit testing frameworks, and collaboration platforms—but you won’t need any specific technology or IDE to follow along. The emphasis is on understanding XP’s mindset and workflow so you can apply it with whatever toolchain your team already uses.

The material is designed for:

- Project managers and Scrum Masters who work with software teams and want to deepen their ability to support engineering practices, not just ceremonies and schedules
- Product Owners and business analysts who need a clearer view of how frequent releases, testing, and close collaboration actually work in a development team
- Software engineers, testers, and technical leads who are curious about XP or looking for a structured way to improve code quality and feedback cycles
- Release Train Engineers, Agile coaches, and transformation leaders seeking practical ways to blend XP with existing Scrum or SAFe® implementations
- Anyone moving into an Agile delivery role who wants a solid, actionable starting point for applying XP in real projects rather than just learning theory

In this lesson, learners dive into the five core values of Extreme Programming (XP)—Communication, Simplicity, Feedback, Courage, and Respect—and learn how to apply them to build higher-quality software in a collaborative environment. By the end, they will be able to clearly explain each value, recognize what it looks like in day-to-day team behavior, and use these values to guide decisions about coding practices, team interactions, and process improvements. Learners will also be able to connect XP values to other agile methods they already know, such as Scrum and SAFe, and see how these values enhance their work when using tools like Jira and agile boards.

The lesson is primarily conceptual and practice-focused rather than tool-focused. However, it references common agile tooling—such as Jira or similar backlog and sprint tools—to show how XP values can be reinforced through team workflows, task breakdown, pair programming rotation, feedback cycles, and continuous improvement practices. No specific software installation or hands-on tooling configuration is required in this lecture; the emphasis is on mindset, behaviors, and practical examples that can be applied regardless of the chosen toolset.

This lesson is intended for project managers, Scrum Masters, Product Owners, team leads, software engineers, QA specialists, business analysts, and anyone working in or transitioning to agile product development teams. It’s especially relevant for professionals who already have some familiarity with agile or Scrum and want to deepen their understanding of Extreme Programming to improve collaboration, code quality, and delivery discipline across their teams.

In this practical, team-focused exercise, learners apply Extreme Programming (XP) practices end-to-end on a realistic mini-project, transforming theory into hands-on experience. By the end of the lesson, learners will be able to:

- Turn a simple product vision into well-structured user stories and acceptance criteria suitable for XP-style development.
- Break down work into small, testable increments and prioritize them for a short XP iteration.
- Practice pair programming roles (driver and navigator), including how to switch roles, communicate effectively, and share ownership of code.
- Apply test-driven development (TDD): writing a failing test first, implementing just enough code to pass, and then refactoring safely.
- Use continuous integration habits on a small scale—frequent commits, small changes, and team visibility of work in progress.
- Run lightweight collective code reviews, incorporating team feedback and improving code quality collaboratively.
- Reflect as a team in a mini-retrospective, capturing what worked, what didn’t, and specific improvements for the next iteration.

This lesson is intentionally tool-light so learners can focus on the core XP practices rather than specific platforms. Typical tools and technologies demonstrated may include:

- A shared code editor or IDE (such as VS Code or IntelliJ) to simulate a real development environment.
- A simple version control workflow (for example, Git) to model frequent, small, collaborative commits.
- A basic unit testing framework in a mainstream language (for instance, JUnit, NUnit, or Jest) to illustrate TDD and automated tests.
- A collaboration space or whiteboard tool (physical or digital) to capture user stories, tasks, and team agreements.

The lesson is designed for:

- Project managers and Scrum Masters who want to understand how XP practices are executed in real team settings and how to support them.
- Agile and Scrum practitioners looking to deepen their skills with concrete XP techniques like pair programming and TDD.
- Software developers, QA engineers, and technical leads who work in Agile environments and want a structured way to practice XP as a team.
- Product owners, business analysts, and other stakeholders who need visibility into how collaborative, test-first development impacts product quality and delivery flow.

No prior XP implementation experience is required; familiarity with basic Agile concepts and software development workflows will help learners get the most out of this team-oriented exercise.

In this lesson, you dive into the foundational practices that make Extreme Programming (XP) such a powerful agile software development approach. By the end of the session, you’ll understand the core principles behind XP and be able to explain how these practices can dramatically improve code quality, collaboration, and responsiveness to change in real-world projects.

You’ll explore key XP practices such as pair programming, test-driven development (TDD), continuous integration, collective code ownership, simple design, refactoring, and small releases. You’ll see how each practice works, why it exists, and how it fits together with Scrum, Agile ways of working, scaling frameworks like SAFe®, and practical project tracking in tools like Jira®. You’ll be able to map XP practices onto your existing agile process and identify concrete steps to start introducing XP into your team: for example, setting up regular pairing sessions, defining a TDD workflow, and designing a lightweight continuous integration pipeline that supports frequent, reliable builds.

This lesson is tool-agnostic at its core. The concepts you learn are applicable with any modern development stack, IDE, or CI system. However, when illustrating how XP can be combined with broader agile project management, the lecture references common tooling patterns using Jira® for managing user stories and tasks in an XP context, and typical CI/CD platforms (such as Jenkins, GitHub Actions, or similar) for implementing continuous integration and automated testing. These references help you visualize how XP practices plug into the larger tooling ecosystem you may already be using.

The lesson is designed for a broad professional audience involved in software products and projects, including:

- Project managers and Scrum Masters transitioning into more engineering-focused agile methods and wanting to understand how XP complements Scrum and SAFe®
- Product Owners and business analysts who need insight into how technical practices like TDD, refactoring, and continuous integration enable faster, more reliable delivery
- Software developers and engineers who want a structured overview of XP practices and how to apply them in a modern agile environment
- Team leads, engineering managers, and release train engineers looking to strengthen technical excellence within their agile or scaled agile teams

Whether you are managing projects, defining requirements, or writing code, this lesson equips you with a clear, practical understanding of the key XP practices and how to start using them to build better software together.

In this lesson, you dive deeper into the core practices of Extreme Programming (XP) and see how they translate into concrete behaviors on real projects. By the end, you’ll be able to explain and apply key XP practices such as Test-Driven Development (TDD), continuous integration, collective code ownership, refactoring, simple design, and sustainable pace. You’ll understand how these practices fit into an Agile and Scrum environment, how they complement frameworks like SAFe®, and how they can be coordinated with day-to-day work tracking in tools like Jira®. You will be able to describe step-by-step how to introduce XP practices into an existing team, how to handle common objections or pitfalls, and how to measure whether these practices are actually improving quality and flow.

The lesson conceptually references modern Agile tooling—particularly Jira®—to illustrate how XP practices can be visualized and managed in a real-world project environment. You’ll see how user stories, tasks, and defects support XP’s fast feedback loops, and how integrating automated tests and continuous integration into your build pipeline reinforces XP’s technical discipline. While you won’t be walked through a specific IDE or CI server setup, you will gain a clear understanding of how XP’s engineering practices plug into typical Agile toolchains.

This lesson is designed for project managers, Scrum Masters, product owners, team leads, and aspiring Agile practitioners who want to move beyond process mechanics and actually improve how software is built. It’s equally valuable for developers, QA engineers, business analysts, and anyone working within Agile, Scrum, or SAFe® who needs a practical, hands-on understanding of XP and how these disciplined engineering practices can dramatically raise product quality, reduce rework, and foster true collaboration within cross-functional teams.

In this closing lesson on Extreme Programming, you’ll get a curated, easy‑to-navigate set of resources that will help you deepen and sustain your XP practice long after the course ends. By the end of the lesson, you’ll be able to confidently choose books, articles, videos, communities, and practice guides that match your role, your team’s maturity level, and your organization’s context.

You will learn how to:
- Identify the most authoritative books and reference guides for Extreme Programming, including where to start if you’re new vs. where to go next for advanced practices.
- Select practical resources for core XP techniques such as pair programming, test‑driven development (TDD), continuous integration, refactoring, simple design, and collective code ownership.
- Build a personal learning roadmap so you know what to read, watch, and experiment with in the next 30, 60, and 90 days.
- Find and evaluate online communities, forums, and conferences where experienced XP practitioners share real‑world experiences and patterns.
- Map XP resources to your existing Agile, Scrum, SAFe, and Jira environment, so XP doesn’t feel like “one more framework” but a way to enhance what you’re already doing.
- Use checklists, quick‑start guides, and templates (provided as downloadable resources) to introduce or strengthen XP practices in your team.

This lesson does not introduce new software tools; instead, it focuses on learning resources. However, where relevant, it points you to:
- Documentation and guides that show how XP engineering practices can be supported in common toolchains (for example, Git-based workflows, CI/CD platforms, unit testing frameworks).
- Hands-on tutorials and code katas hosted on popular platforms you can use to practice TDD, refactoring, and pair programming with your preferred language and IDE.

The lesson is intended for:
- Project managers and Scrum Masters who want to ground their leadership in strong engineering practices and speak the same language as development teams.
- Product Owners and business stakeholders who need to understand what XP teams do differently so they can set expectations and collaborate more effectively.
- Software engineers, QA engineers, and DevOps professionals looking for a structured set of next steps to deepen their XP craft.
- Agile and SAFe practitioners seeking to complement their framework knowledge with concrete, team‑level technical practices.
- Team leads and engineering managers who plan to introduce or reinforce XP within their teams and need credible, practical references to support change.