Agile Approaches
Open in the Padhaiko app3.1 The Umbrella of Agile Approaches: Broad overview
Agile is not a single rigid methodology; it is an umbrella mindset defined by the 4 values and 12 principles of the Agile Manifesto. Underneath that umbrella sits a family of complementary frameworks and engineering methods, each emphasizing a different facet of product delivery.
The Agile Umbrella
The Agile Umbrella groups iterative, incremental, and flow-based methodologies that share empirical control, customer collaboration, and adaptive planning while differing in cadence, prescribed roles, and engineering rigor. Most mature teams combine practices across multiple approaches—for example, using Scrum for planning cadence, XP for technical practices, and Kanban for workflow visualization.
| Approach | Primary Focus | Typical Cadence / Flow | Signature Mechanisms |
|---|---|---|---|
| Scrum | Empirical product management and team accountability | Fixed-length Sprints (1–4 weeks) | 3 Roles (PO, SM, Developers), 3 Artifacts, 5 Events |
| Kanban | Visualizing flow and matching WIP to capacity | Continuous flow (pull-based) | Kanban board, explicit WIP limits, Cycle Time & Lead Time |
| Extreme Programming (XP) | Engineering excellence and low defect rates | Very short releases (1–2 weeks) + continuous integration | TDD, Pair Programming, Refactoring, Simple Design, CI |
| Lean Product Development | Maximizing customer value and eliminating waste | Value-stream flow | 7 Wastes, Amplify Learning, Defer Commitment, Optimize Whole |
| Crystal Family (Cockburn) | Tailoring ceremony weight to team size and project criticality | Iterative (1–4 months max) | Osmotic communication, reflective improvement |
| FDD (Feature-Driven Dev.) | Modeling and building tangible client-valued features | Short feature iterations (2 days–2 weeks) | Domain object modeling, feature lists, design/build by feature |
| DSDM | Business-driven governance for enterprise projects | Timeboxes with MoSCoW prioritization | Must/Should/Could/Won't scope control, early prototyping |
3.2 Lean Product Development: Principles (eliminate waste, amplify learning, fast delivery)
Adapted from the Toyota Production System (TPS) by Mary and Tom Poppendieck in Lean Software Development, Lean Product Development focuses on delivering maximum customer value through a smooth value stream while relentlessly removing anything that adds cost without adding user value.
The Seven Principles of Lean Software Development
- Eliminate Waste: Remove every activity, artifact, or feature that does not directly create value for the customer.
- Amplify Learning: Treat software development as continuous discovery using short feedback loops, prototypes, spikes, and user testing.
- Decide as Late as Possible (Defer Commitment): Keep design and business options open until the last responsible moment—the point where failing to decide eliminates an important alternative.
- Deliver as Fast as Possible: Shrink batch sizes and remove delays so customers receive value rapidly and feedback returns before assumptions go stale.
- Empower the Team: Respect the people doing the work; let local technical experts make design decisions rather than centralizing approvals.
- Build Integrity In: Ensure both perceived integrity (the product feels cohesive to users) and conceptual integrity (clean, tested, refactored architecture).
- Optimize the Whole (See the Whole): Optimize the end-to-end concept-to-cash value stream rather than locally optimizing one department (e.g., rushing coding while creating a huge QA bottleneck).
3.2.1 The Seven Wastes of Software Development
In Lean, any step that consumes time or money without improving the customer's outcome is waste (muda):
| Lean Software Waste | Concrete Example in Software Projects | Lean Countermeasure |
|---|---|---|
| 1. Partially Done Work | Unmerged branches, untested code, or unreviewed specs sitting idle for weeks. | Small stories finished end-to-end inside each iteration; Continuous Integration. |
| 2. Extra Features (Gold Plating) | Building complex settings or speculative features customers never requested or use. | Simplicity (Manifesto Principle 10), MVP validation, strict backlog prioritization. |
| 3. Relearning | Solving the same bug twice or rediscovering lost knowledge when staff rotate. | Automated regression tests, pair programming, concise living docs. |
| 4. Handoffs | Passing specs from BA -> Architect -> Developer -> Tester -> Ops via tickets. | Cross-functional product teams collaborating daily without organizational walls. |
| 5. Delays | Waiting days for environment provisioning, manager sign-offs, or code reviews. | Self-service CI/CD pipelines, empowered team authority, WIP limits. |
| 6. Task Switching | Assigning a developer to 3–4 simultaneous projects, causing constant context loss. | Dedicated single-team focus and strict WIP limits. |
| 7. Defects | Bugs escaping to late QA or production, multiplying fix and support cost. | Test-Driven Development (TDD), pair programming, automated build verification. |
3.2.2 Deep Dive on Three Core Syllabus Pillars
- Eliminate Waste: Identify value-adding vs. non-value-adding steps using Value Stream Mapping; cut unused features and waiting queues first.
- Amplify Learning: Because software is design, not repetitive manufacturing, run small experiments (technical spikes, paper prototypes, short sprints) and feed real user behavior back into the backlog.
- Deliver as Fast as Possible: Speed and quality reinforce each other—small batches move quickly through the pipeline, expose defects immediately, and shrink the window during which requirements can drift.
3.3 Kanban: Managing flow and limiting work in progress (WIP)
Kanban (Japanese for "visual signal" or "signboard") is a pull-based flow management method formalized for software and knowledge work by David J. Anderson. Unlike Scrum, Kanban does not prescribe fixed-length sprints or mandatory roles; instead, it overlays evolutionary flow discipline onto an existing process.
Core Principles and Practices of Kanban
Kanban focuses on continuous flow governed by six core practices:
- Visualize the Workflow: Represent every stage of work as columns on a Kanban board (e.g.,
Backlog | Ready | In Dev | Code Review | Testing | Done). - Limit Work in Progress (WIP): Cap the maximum number of items allowed inside each active column (e.g.,
In Dev [Max 3],Testing [Max 2]). New work is pulled only when a slot opens downstream. - Manage Flow: Monitor work movement continuously to eliminate stalls, queues, and bottlenecks.
- Make Process Policies Explicit: Post clear, shared rules (such as Definition of Ready and exit criteria for each column).
- Implement Feedback Loops: Hold regular stand-ups ("walk the board" right-to-left), service delivery reviews, and replenishment meetings.
- Improve Collaboratively, Evolve Experimentally: Use flow metrics to test small Kaizen improvements.
3.3.1 Why Limiting WIP Improves Throughput and Speed
When teams start too many items simultaneously ("push system"), developers context-switch constantly, code reviews pile up, and every item sits waiting in queues. Limiting WIP creates a pull system:
- If
Testing [Max 2]is full, developers stop starting new features and swarm to help finish testing the blocked items so flow resumes. - Little's Law mathematically links WIP, Throughput, and Cycle Time in a stable flow system:
Average Cycle Time (CT) = Average WIP / Average Throughput (TH)
Lead Time = Time from customer request (commitment) to Done
Cycle Time = Time from starting active work to Done
Throughput (TH) = Items completed per unit time (e.g., stories per week)By Little's Law, if team Throughput stays constant (or rises due to less context switching), cutting WIP in half cuts Cycle Time in half!
3.4 Scrum Framework: Roles (Scrum Master, Product Owner, Dev Team), artifacts, and events
Scrum is a lightweight framework created by Ken Schwaber and Jeff Sutherland that uses empirical process control to help people, teams, and organizations generate value through adaptive solutions for complex problems.
The Scrum 3-3-5 Structure
Scrum is built around 3 Roles (Accountabilities), 3 Artifacts (each with an explicit commitment), and 5 Events inside a 1–4 week Sprint:
- 3 Roles: Product Owner, Scrum Master, Development Team (Developers).
- 3 Artifacts: Product Backlog (Product Goal), Sprint Backlog (Sprint Goal), Increment (Definition of Done).
- 5 Events: Sprint, Sprint Planning, Daily Scrum, Sprint Review, Sprint Retrospective.
3.4.1 Scrum Roles (Accountabilities)
- Product Owner (PO): Single person accountable for maximizing the value of the product. Owns the Product Backlog—creating, clearly communicating, and ordering items by value, risk, and dependencies.
- Scrum Master (SM): Servant-leader accountable for establishing Scrum as defined in the Scrum Guide, coaching the team and organization on empiricism and self-management, facilitating events when requested, and helping remove systemic impediments. Has no line-management authority to command tasks.
- Development Team (Developers): Cross-functional, self-organizing professionals (typically 3–9 members) who hold all skills needed to create a usable Increment every Sprint. They own the Sprint Backlog, estimate work, uphold the Definition of Done, and decide how to execute tasks.
3.4.2 Scrum Artifacts and Their Commitments
| Artifact | Owner | Purpose | Associated Commitment |
|---|---|---|---|
| Product Backlog | Product Owner | Emergent, ordered list of everything needed to improve the product. | Product Goal (long-term objective for the product) |
| Sprint Backlog | Developers | Selected Product Backlog items + actionable plan for delivering the Increment. | Sprint Goal (single unifying objective for the current Sprint) |
| Increment | Whole Scrum Team | Concrete stepping stone toward the Product Goal; additive sum of all completed items. | Definition of Done (DoD) (formal quality criteria required for shippable work) |
3.4.3 The Five Scrum Events
| Event | Timebox (1-Month Sprint) | Typical (2-Week Sprint) | Participants | Core Objective (Inspect & Adapt) |
|---|---|---|---|---|
| 1. The Sprint | 1–4 weeks (fixed) | 2 weeks | Whole Scrum Team | Container event enclosing all other events to produce a Done Increment. |
| 2. Sprint Planning | Max 8 hours | ~4 hours | Whole Scrum Team | Define Why (Sprint Goal), What (selected PBIs), and How (initial work plan). |
| 3. Daily Scrum | Max 15 minutes daily | 15 minutes daily | Developers (SM/PO optional) | Inspect progress toward the Sprint Goal and adapt the next 24-hour plan. |
| 4. Sprint Review | Max 4 hours | ~2 hours | Scrum Team + Stakeholders | Inspect the working Increment, gather feedback, and adapt the Product Backlog. |
| 5. Sprint Retrospective | Max 3 hours | ~1.5 hours | Whole Scrum Team | Inspect people, interactions, processes, tools, and DoD; plan improvements. |
3.5 Extreme Programming (XP): Engineering practices (TDD, refactoring, pair programming)
Created by Kent Beck in the late 1990s, Extreme Programming (XP) takes proven software engineering practices and applies them continuously at an "extreme" level to keep the cost of changing code flat over time. XP is grounded in five values: Communication, Simplicity, Feedback, Courage, and Respect.
Core XP Engineering Practices
- Test-Driven Development (TDD): Developers write an automated unit test before writing production code, following the Red -> Green -> Refactor micro-cycle.
- Refactoring: Continuously restructuring existing code to improve clarity, modularity, and remove duplication without changing external observable behavior, verified by the automated test suite.
- Pair Programming: All production code is written by two programmers sharing one workstation—the Driver types and focuses on tactical syntax, while the Navigator reviews strategy, edge cases, and design continuously, swapping roles often.
- Continuous Integration (CI): Every developer integrates and tests code against the main trunk multiple times per day, keeping the build permanently green.
- Simple Design & Collective Ownership: Write the simplest code that passes all tests today (YAGNI — You Aren't Gonna Need It), and allow any team member to improve any file in the codebase.
3.5.1 The TDD Red-Green-Refactor Cycle
1. RED : Write a small automated unit test for one new behavior; run it and watch it FAIL.
2. GREEN : Write the simplest production code needed to make the test PASS.
3. REFACTOR : Clean up duplication, improve naming/design, and re-run ALL tests to confirm GREEN.
(Repeat every few minutes!)- Why Pair Programming Works: Although two developers share one keyboard, studies and XP experience show defect rates drop sharply, design quality improves, knowledge spreads across the team ("bus factor" rises), and onboarding accelerates.
| Feature | Scrum | Kanban | Extreme Programming (XP) |
|---|---|---|---|
| Cadence | Fixed-length Sprints (1–4 weeks) | Continuous flow (no required sprints) | Very short iterations (1–2 weeks) + daily CI |
| Prescribed Roles | PO, Scrum Master, Developers | No mandatory new roles | Customer, Coach, Programmer, Tracker |
| Change Policy | Avoid changes mid-sprint that endanger Sprint Goal | Pull new items anytime a WIP slot opens | Welcomes changes even mid-iteration if work hasn't started |
| WIP Control | Implicit via Sprint capacity | Explicit WIP limits per board column | Small stories + single-piece continuous flow |
| Engineering Practices | Not prescribed (team chooses) | Not prescribed | Strictly prescribed (TDD, Pairing, CI, Refactoring) |
3.1
A software team uses Kanban to process user stories. Initially, they have no WIP limit: on average 12 stories sit in active development at once (WIP = 12), and they complete 4.0 stories per week (Throughput = 4.0 stories/week).
- Using Little's Law, calculate the team's average Cycle Time (in weeks).
- Management introduces a strict column WIP limit capping active work at 6 stories (
WIP = 6). Assuming throughput initially stays at 4.0 stories/week, what is the new average Cycle Time? - If reduced context switching boosts throughput by 20% to 4.8 stories/week at
WIP = 6, calculate the improved Cycle Time and the overall percentage reduction in Cycle Time compared to the original baseline.
Baseline Cycle Time (Unbounded WIP = 12): By Little's Law, Cycle Time = WIP / Throughput:
- Cycle Time (baseline) = 12 / 4.0 = 3.00 weeks per story.
Immediate Effect of Capping WIP at 6 (Constant Throughput = 4.0):
- Cycle Time (WIP = 6, TH = 4.0) = 6 / 4.0 = 1.50 weeks per story (a 50% reduction solely from cutting queue congestion).
Cycle Time with Higher Throughput (WIP = 6, TH = 4.8):
- Cycle Time (improved) = 6 / 4.8 = 1.25 weeks per story.
- Percentage reduction from baseline = ((3.00 - 1.25) / 3.00) x 100 = (1.75 / 3.00) x 100 = 58.33%.
- Baseline Cycle Time: 3.00 weeks
- Cycle Time at WIP = 6 (TH = 4.0): 1.50 weeks
- Cycle Time at WIP = 6 (TH = 4.8): 1.25 weeks (58.33% faster than baseline)
3.2
A Scrum team runs 2-week (10-working-day) Sprints, scaling standard 1-month (4-week) Scrum event timeboxes proportionally (except Daily Scrum, which is always 15 minutes/day). Calculate the scaled timebox in hours for:
- Sprint Planning
- Daily Scrum (total across 10 working days)
- Sprint Review
- Sprint Retrospective
- Total ceremony time per 2-week Sprint.
Scaling Ratio for a 2-Week Sprint vs. 1-Month (4-Week) Sprint: Scale factor = 2 weeks / 4 weeks = 0.5.
- Sprint Planning: 8 hours x 0.5 = 4.0 hours.
- Sprint Review: 4 hours x 0.5 = 2.0 hours.
- Sprint Retrospective: 3 hours x 0.5 = 1.5 hours.
Daily Scrum Total and Overall Ceremony Time: Daily Scrum is fixed at 15 minutes (0.25 hours) per working day regardless of Sprint length:
- Daily Scrum (10 days): 10 x (15 / 60) = 2.5 hours.
- Total ceremony time: 4.0 + 2.0 + 1.5 + 2.5 = 10.0 hours across the 2-week Sprint.
- Sprint Planning: 4.0 hours
- Daily Scrum (10 days): 2.5 hours total (15 minutes/day)
- Sprint Review: 2.0 hours
- Sprint Retrospective: 1.5 hours
- Total Ceremony Time: 10.0 hours per 2-week Sprint
3.3
Exam-Style Application Question: A 6-person team uses Scrum, holds all five events on time, and delivers features every 2 weeks—yet every third sprint is spent exclusively fixing regression bugs, and developers refuse to edit complex legacy billing modules written by a colleague who left. Identify which Agile approach addresses this gap and recommend three concrete practices from it.
Diagnosing the Gap: Scrum provides the project management cadence (roles, artifacts, events) but does not prescribe technical engineering practices. Regression spikes and fear of touching legacy modules indicate missing Extreme Programming (XP) engineering discipline (and Lean's Build Integrity In principle).
Three Concrete XP Practices to Adopt:
- Test-Driven Development (TDD): Build an automated unit and regression test suite so refactoring legacy code no longer risks silent regressions.
- Pair Programming & Collective Code Ownership: Pair developers on the billing module so knowledge spreads and no single module remains "untouchable."
- Continuous Refactoring & CI: Run automated tests on every commit and refactor duplicated or brittle code incrementally inside every sprint rather than waiting for dedicated "bug-fix sprints."
Adopt Extreme Programming (XP) engineering practices alongside Scrum—specifically TDD (automated safety net against regressions), Pair Programming with Collective Code Ownership (eliminating single-person code silos), and Continuous Refactoring + CI (keeping technical debt under control every sprint).
Exercises
Practice Exercises — Agile Approaches
Explain why Agile is described as an "umbrella" rather than a single methodology, and summarize when an organization would choose Scrum, Kanban, or Extreme Programming (XP).
Why Agile Is an Umbrella: The Agile Manifesto defines 4 shared values and 12 principles, not a single process recipe. Multiple frameworks implement those values in different ways depending on product stability, team size, and technical needs.
Choosing Between Scrum, Kanban, and XP:
- Scrum: Best when a cross-functional team builds a complex product in predictable 1–4 week rhythms requiring regular stakeholder Sprint Reviews and clear Product Owner prioritization.
- Kanban: Best for continuous-flow environments (operations, support, maintenance, DevOps) where priorities arrive unpredictably and controlling WIP/Cycle Time matters more than fixed sprints.
- Extreme Programming (XP): Best (often layered inside Scrum) when high code change rates demand strict software engineering rigor—TDD, refactoring, pair programming, and continuous integration.
Agile is an umbrella of values/principles encompassing diverse practices: Scrum structures empirical sprint cadence and roles, Kanban optimizes continuous pull flow via WIP limits, and XP enforces disciplined coding practices to sustain rapid change.
State the seven principles of Lean Software Development and identify five of the seven Lean wastes with one software-engineering countermeasure for each.
Seven Lean Software Development Principles:
- Eliminate Waste, 2. Amplify Learning, 3. Decide as Late as Possible, 4. Deliver as Fast as Possible, 5. Empower the Team, 6. Build Integrity In, 7. Optimize the Whole.
Five Lean Wastes and Countermeasures:
- Partially done work -> Complete small vertical stories end-to-end every sprint with CI.
- Extra features (gold plating) -> Prioritize strictly by customer value (MVP/Simplicity).
- Handoffs -> Form cross-functional teams containing dev, test, and UX together.
- Task switching -> Dedicate developers to one team and cap active WIP.
- Defects -> Apply TDD, pair programming, and automated regression suites.
Lean rests on Eliminate Waste, Amplify Learning, Decide as Late as Possible, Deliver Fast, Empower the Team, Build Integrity In, and Optimize the Whole. Key wastes—partially done work, extra features, handoffs, task switching, and defects—are eliminated via small batches, cross-functional teams, WIP limits, and TDD/CI.
Describe the Scrum 3-3-5 framework (3 roles, 3 artifacts with their commitments, and 5 events), and explain how empirical process control operates inside each event.
3 Roles and 3 Artifacts (+ Commitments):
- Roles: Product Owner (value maximization), Scrum Master (Scrum coaching and impediment removal), Developers (cross-functional increment delivery).
- Artifacts & Commitments: Product Backlog (Product Goal), Sprint Backlog (Sprint Goal), Increment (Definition of Done).
5 Events and Empiricism:
- The Sprint: Timeboxed container (1–4 weeks) ensuring regular inspection/adaptation loops.
- Sprint Planning: Inspects Product Backlog and capacity to adapt a Sprint Goal and plan.
- Daily Scrum: 15-minute developer inspection of Sprint Goal progress to adapt daily work.
- Sprint Review: Inspects the Done Increment with stakeholders to adapt the Product Backlog.
- Sprint Retrospective: Inspects team interactions, tools, and DoD to adapt team practices.
Scrum comprises 3 roles (Product Owner, Scrum Master, Developers), 3 artifacts with commitments (Product Backlog/Product Goal, Sprint Backlog/Sprint Goal, Increment/Definition of Done), and 5 timeboxed events (Sprint, Sprint Planning, Daily Scrum, Sprint Review, Sprint Retrospective) that enforce transparency, inspection, and adaptation.
Explain Test-Driven Development (TDD), Refactoring, and Pair Programming in Extreme Programming (XP), and describe how these three practices reinforce one another.
Individual Definitions:
- TDD: Write a failing unit test first (Red), write minimal passing code (Green), then clean up structure (Refactor).
- Refactoring: Improving internal code readability and modularity without altering external behavior.
- Pair Programming: Two programmers share one workstation as Driver (typing) and Navigator (continuous design/edge-case review).
Mutual Reinforcement: TDD creates an automated regression safety net that makes Refactoring safe and fearless. Pair Programming catches design flaws early during TDD, spreads codebase familiarity, and ensures refactoring standards are upheld consistently.
TDD follows Red-Green-Refactor, Refactoring cleans internal design without altering behavior, and Pair Programming combines a tactical Driver with a strategic Navigator. Together, TDD makes refactoring safe while pairing boosts test and design quality.
A DevOps Kanban team currently has an average of 15 tickets in progress (WIP = 15) and a steady throughput of 3.0 tickets per day (TH = 3.0 tickets/day).
- What is the team's current average Cycle Time in days?
- If the team enforces explicit column limits that bring average WIP down to 6 tickets while maintaining throughput at 3.0 tickets/day, what is the new Cycle Time and the percentage improvement?
Current Average Cycle Time: Using Little's Law (Cycle Time = WIP / Throughput):
- Cycle Time (before) = 15 / 3.0 = 5.0 days per ticket.
New Cycle Time and Percentage Improvement:
- Cycle Time (after WIP limit) = 6 / 3.0 = 2.0 days per ticket.
- Reduction = 5.0 - 2.0 = 3.0 days.
- Percentage improvement = (3.0 / 5.0) x 100 = 60.0%.
- Current Cycle Time: 5.0 days
- New Cycle Time at WIP = 6: 2.0 days (60.0% faster delivery)