Chapter 3

Agile Project
Management Framework
 Introduction
• Agile is a modern approach to software project management that focuses
on flexibility, collaboration, and customer-centric delivery. Unlike traditional
project management methods, such as the Waterfall model, Agile embraces
change, continuous feedback, and iterative development. Agile has become
widely popular due to its ability to deliver high-quality products faster while
adapting to evolving customer needs and market conditions.
• Agile methodologies are particularly useful in complex and fast-paced
environments where project requirements may shift during development. It
encourages cross-functional teamwork, frequent communication, and
continuous improvement, making it a preferred choice for many software
development teams worldwide.
 Definition
• Agile is a set of principles and practices for software project management and
development that emphasize iterative progress, collaboration, and
adaptability. It is guided by the Agile Manifesto, which highlights four core
values:
1.Individuals and interactions over processes and tools
2.Working software over comprehensive documentation
3.Customer collaboration over contract negotiation
4.Responding to change over following a plan
Agile Project Life Cycle
• The Agile project life cycle consists of iterative and incremental
phases that focus on continuous delivery, adaptation, and
improvement. Unlike the traditional linear project life cycle, Agile
breaks down the project into smaller, manageable iterations or
sprints, allowing teams to deliver working solutions frequently and
respond to change quickly.
• Here’s an overview of the key stages of the Agile project life cycle:
1. Concept / Envision Phase
Goal: Define the project vision, high-level scope, and business objectives.
• Identify stakeholders, business goals, and key requirements.
• Develop a product backlog (a prioritized list of features or tasks).
• Create a high-level roadmap and an initial project plan.
Deliverables:
• Product vision statement
• Initial product backlog
• Roadmap
2. Planning / Release Planning
Goal: Plan the first iteration (or sprint) and break down the high-priority
features into actionable tasks.
• Prioritize the product backlog.
• Define iteration goals and scope for the upcoming sprint.
• Estimate tasks and allocate resources.
• Deliverables:
• Iteration backlog (a set of tasks for the sprint)
• Definition of Done (DoD) criteria
3. Iteration Execution / Iterative Development
Goal: Develop and deliver working software incrementally within each iteration.
• The team works on tasks in short cycles (usually 1–4 weeks).
• Continuous collaboration between developers, testers, and stakeholders.
• Daily stand-up meetings to monitor progress and address roadblocks.
• Regular integration and testing to ensure quality.
Deliverables:
• Working software at the end of each sprint
• Sprint burndown charts to track progress
4. Review
Goal: Inspect and adapt the product and processes.
• Sprint Review: Present the working product to stakeholders and gather
feedback.
• Sprint Retrospective: Reflect on what went well, what didn’t, and how to
improve in the next iteration.
Deliverables:
• Stakeholder feedback
• Actionable improvement plan
5. Release / Deployment
• Goal: Deliver the product to users and ensure it meets business objectives.
• Deploy the increment to production if it meets the Definition of Done.
• Collect user feedback for future iterations.
• Deliverables:
• Released product increment
• Updated backlog for future enhancements
6. Closure (if applicable)
• Agile projects may not have a defined closure phase in the traditional sense. Instead, the
product evolves continuously. However, when the product reaches maturity or business
goals are met, the project can transition into a maintenance phase or be formally closed.
Key Activities:
• Final release
• Documentation
• Lessons learned
Principles of Agile in Software Project
Management
1. Customer satisfaction through early and continuous delivery of valuable
software.
2. Welcome changing requirements, even late in development, to provide a
competitive advantage.
3. Deliver working software frequently, with a preference for shorter
timescales.
4. Business people and developers must work together daily throughout the
project.
5. Face-to-face communication is the most efficient and effective method of
conveying information.
6. Working software is the primary measure of progress.
7. Maintain a sustainable pace to promote long-term productivity.
8. Self-organizing teams produce the best designs, architectures, and
solutions.
Key Agile Concepts in software project
management
1. Iterative and Incremental Development
• Agile projects are broken down into smaller, manageable cycles called
iterations or sprints (usually 1–4 weeks).
• Each iteration delivers a potentially shippable product increment, allowing for
continuous improvement.
2. Customer-Centric Approach
• Customer collaboration is prioritized over rigid contracts.
• Frequent feedback from the customer ensures the product aligns with their
needs and business goals.
3. Adaptive Planning
• Plans are flexible and continuously updated based on feedback and changing
priorities.
• Focus is on short-term goals while keeping the long-term vision in mind.
4. Continuous Delivery
• Agile emphasizes delivering working software frequently (every few weeks),
reducing the time between idea and delivery.
• Enables early detection of issues and ensures continuous improvement.
5. Self-Organizing Teams
• Teams have the autonomy to make decisions about how to complete their
work.
• Encourages collaboration, innovation, and accountability.
6. Prioritized Backlog
• Work items are organized and prioritized in a product backlog, ensuring the
team focuses on the most valuable features first.
• Prioritization is based on business value, customer needs, and technical
dependencies.
7. Continuous Improvement
• Teams regularly reflect on their performance through evalutaion at the end of
each iteration.
• Identifying what worked well and what needs improvement fosters a culture of
learning.
8. Definition of Done (DoD)
• A shared understanding of what it means for a task or feature to be considered
"done.“
• Includes criteria such as code completion, testing, documentation, and
deployment readiness.
 Defect Management Process
Key Steps in the Defect Management Process
1.Defect Identification
1. Defects are found during testing, code reviews, or user feedback.
2. Testers log defects when expected results differ from actual results.
2.Defect Logging
1. The defect is recorded in a defect tracking system (e.g., Jira, Bugzilla, or Redmine).
2. Key details include:
1. Defect ID
2. Description
3. Severity (Critical, Major, Minor)
4. Priority (High, Medium, Low)
3. Defect Triage
•A triage team reviews defects to determine priority and severity.
•They decide whether the defect should be fixed immediately or
scheduled for later.
4. Defect Assignment
•The defect is assigned to a developer for resolution.
•Developers analyze and fix the issue.
5. Defect Resolution
•The developer fixes the defect and updates the defect status (e.g.,
"Fixed" or "Resolved").
•Code changes are reviewed and merged.
6. Defect Retesting
•The QA team verifies the fix by testing the scenario again.
•If the defect is still present, it is reopened and sent back to the
developer.
7. Defect Closure
•If the fix is successful, the defect is marked as "Closed."
•A final report may be generated for tracking and process
improvement.
 Agile vs. Traditional Project
Feature Management
Agile Project Management Traditional (Waterfall) Project Management
Approach Iterative & Incremental Linear & Sequential
Project Phases Overlapping & adaptive Defined & sequential (e.g., Requirements → Design
→ Development → Testing → Deployment)

Flexibility Highly flexible; changes can be made anytime Rigid; changes are difficult after a phase is
completed

Customer Continuous involvement & feedback Limited to the beginning and end
Involvement

Deliverables Delivered in small increments (sprints) Delivered at the end of the project
Testing Continuous testing throughout development Testing happens after development
Risk Management Managed in short cycles, reducing risk High risk if issues are found late
Team Structure Self-organizing, cross-functional teams Defined roles & hierarchy
Documentation Lightweight, focuses on working software Heavy documentation required before
development

Best for Dynamic projects (e.g., Software Development) Well-defined, stable projects (e.g., Construction,
Manufacturing)