SkarpChapter 12 of 20
Kanban, Extreme Programming, and Flow-Based Agile
Move beyond Scrum to see how Kanban and Extreme Programming manage work and quality through flow, limits, and disciplined engineering practices. You’ll learn how to spot these frameworks in exam questions and how they complement or differ from Scrum.
From Scrum to Flow-Based Agile
Beyond Scrum
You have seen how Scrum uses fixed-length sprints with clear roles and events. Now you will explore flow-based agile approaches: Kanban and Extreme Programming (XP).
What Is Flow-Based Agile?
Flow-based agile focuses less on timeboxes and more on keeping work moving smoothly, reducing delays, and improving quality through disciplined engineering practices.
Exam-Relevant Goals
For CAPM you must recognize what Kanban and XP are, how they manage work and quality, and how they compare to Scrum in roles, cadence, and work management.
Scrum vs Kanban vs XP
Scrum uses sprints and roles. Kanban uses continuous flow, visual boards, and WIP limits. XP focuses on engineering practices like pair programming and test-driven development.
Agile Mindset Link
All three approaches support the agile mindset: respond to change, deliver frequently, and collaborate closely with stakeholders in knowledge work environments.
Kanban Fundamentals: Visualizing Work and Flow
What Kanban Is
Kanban is a method for managing the flow of work. It began in manufacturing and is now common in knowledge work, especially software, IT, and operations.
Core Principles
Key principles: visualize work on a board, limit work-in-progress, manage flow, make policies explicit, and use feedback loops to improve continuously.
A Simple Board
A basic Kanban board might have columns: Backlog, Ready, In Progress, In Review or Testing, and Done. Each work item is a card that moves left to right.
Why Visualization Matters
The board lets the team see how much work is in each stage, where work is stuck, and which people or steps might be overloaded or idle.
Exam Signal: Kanban
If a scenario shows cards moving continuously on a board with WIP limits or cycle time, and no fixed sprints, you are likely dealing with Kanban.
Work-in-Progress Limits and Flow Metrics
What Are WIP Limits?
Work-in-progress limits cap how many items can be in a column or the whole system. If the limit is reached, no new work starts until something finishes.
Benefits of WIP Limits
WIP limits reduce multitasking, expose bottlenecks, and usually shorten cycle time by keeping the system less crowded and more focused on finishing.
Cycle Time and Lead Time
Cycle time measures how long an item takes from start to finish. Lead time measures from request to delivery. Both are key Kanban flow metrics.
Throughput
Throughput is how many work items are completed per unit time, such as stories per week. It helps forecast future delivery capacity.
Exam Clues
If a scenario emphasizes WIP limits, cycle time, and continuous movement of work instead of sprints, it is signaling a Kanban-style approach.
Kanban in Practice: Service Team Scenario
The Support Team
An IT support team receives unpredictable tickets. They use a Kanban board with columns: Requested, Analyzing, In Progress, Waiting for User, and Done.
Applying WIP Limits
They set WIP limits: Analyzing 2, In Progress 3, Waiting for User 5. When a column is full, they must finish work before starting new items.
Handling Urgent Work
When an urgent ticket arrives and In Progress is full, they finish an existing item first, then pull the urgent ticket, respecting WIP limits.
Using Flow Metrics
They measure cycle time from Analyzing to Done. Long cycle times and piles of DB-related tickets reveal a bottleneck around the database specialist.
Improving the System
They create a DB specialist swimlane, encourage pairing, and lower the In Progress limit. On exams, such behavior signals a Kanban-style system.
Extreme Programming (XP): Overview and Values
What Is XP?
Extreme Programming is an agile approach focused on disciplined software engineering practices to achieve high quality and rapid feedback.
XP Values
XP is based on values of communication, simplicity, feedback, courage, and respect. These guide how the team designs and codes.
Iterations and Releases
XP uses short iterations, frequent releases, and continuous customer involvement to keep feedback loops tight and reduce waste.
Exam-Relevant Practices
On CAPM, XP is signaled by terms like pair programming, test-driven development, continuous integration, refactoring, and collective code ownership.
XP with Scrum
Many teams combine Scrum for work management with XP for engineering. A scenario can therefore show both Scrum events and XP practices together.
Core XP Practices: Pair Programming, TDD, CI, and More
Pair Programming
Pair programming has two developers at one workstation on the same code, frequently swapping roles. It reduces defects and spreads knowledge.
Test-Driven Development
In TDD, developers write an automated test before the code. They follow the cycle: write a failing test, make it pass, then refactor.
Continuous Integration
Continuous integration means developers integrate code into a shared repository many times per day, triggering automated builds and tests.
Refactoring
Refactoring improves the internal structure of code without changing behavior. It keeps the design clean and easier to maintain.
Collective Code Ownership
With collective code ownership, any developer can change any part of the codebase, reducing bottlenecks and knowledge silos.
XP in Practice: Development Team Scenario
The XP Team
A small web app team works in 1-week iterations. For each story they clarify acceptance criteria, then follow an XP-style engineering process.
Writing Tests First
They practice TDD: write automated tests that initially fail, then implement just enough code to make those tests pass for the new feature.
Pair Programming in Action
Two developers share one workstation, one typing and one reviewing. They switch roles and partners often, spreading knowledge and catching defects.
Continuous Integration Pipeline
Whenever they commit code, an automated pipeline builds the system and runs tests. Failing tests are fixed immediately before new work starts.
Exam Interpretation
Scenario phrases like tests written before code, frequent integrations, and pair programming are strong signals that XP practices are being used.
Scrum vs Kanban vs XP: Roles, Cadence, and Work Management
Comparing Roles
Scrum defines Product Owner, Scrum Master, and Developers. Kanban prescribes no roles. XP focuses on developers and a customer but is less formal.
Cadence Differences
Scrum uses fixed sprints. Kanban uses continuous flow with pull. XP uses short iterations but its engineering practices run continuously.
How Scrum Manages Work
Scrum manages work through a product backlog and sprint backlog. The product backlog is an ordered list of needed product items.
How Kanban Manages Work
Kanban manages work using a visual board, WIP limits, and flow metrics like cycle time and throughput, rather than sprint commitments.
How XP Manages Work
XP organizes work into small stories and iterations, but its distinctive feature is disciplined engineering practices such as TDD and CI.
Thought Exercise: Choosing Between Scrum, Kanban, and XP
Use this thought exercise to practice selecting an approach in exam-style scenarios. There are no single "correct" answers here; the goal is to reason clearly.
Scenario A: Unpredictable Support Work
- A small operations team handles production incidents and service requests.
- Work arrives at random times, and priorities change quickly.
- Stakeholders want fast response, not fixed 2-week plans.
Question:
- Which approach (Scrum, Kanban, XP, or a mix) would best fit this situation, and why?
- What artifacts or practices from that approach would be most important?
Suggested reasoning path:
- Identify if work is project-based or ongoing service.
- Check if timeboxing around sprints makes sense.
- Look for flow and WIP control needs.
Scenario B: New Software Product, Quality is Critical
- A cross-functional team is building a new customer-facing app.
- They plan releases every 4 weeks.
- Defects in production would be very costly.
Question:
- Which combination of Scrum, Kanban, and XP practices might you recommend?
- Which specific XP practices would most directly improve quality?
Pause and jot down your answers before moving on. In the next quiz, you will test your ability to spot the signals in more structured questions.
Quiz: Spot the Framework (1)
Answer this multiple-choice question to check your understanding of Kanban vs Scrum vs XP signals.
A team manages its work on a board with columns such as Ready, In Progress, Testing, and Done. Each column has a maximum number of items allowed. Work items are pulled into In Progress whenever someone has capacity, and there are no fixed-length iterations. The team measures the average number of days a work item spends from In Progress to Done. Which approach best describes this way of working?
- Scrum
- Kanban
- Extreme Programming (XP)
- Predictive (waterfall) life cycle
Show Answer
Answer: B) Kanban
This scenario describes a visual board with WIP limits, continuous pull of work (no sprints), and focus on cycle time. Those are classic Kanban characteristics. Scrum would emphasize sprints and sprint backlogs. XP would highlight engineering practices like pair programming and TDD. A predictive life cycle would not use continuous flow with WIP limits.
Quiz: XP Practices in Action (2)
Answer this question to reinforce your understanding of XP engineering practices.
A software team works in 2-week iterations. For each new feature, they first write an automated test that fails, then write just enough code to make the test pass, and finally clean up the code while keeping all tests green. They integrate their code into a shared repository several times per day, triggering automated builds and tests. Which combination of practices is MOST strongly illustrated?
- Pair programming and collective code ownership
- Work-in-progress limits and cycle time measurement
- Test-driven development and continuous integration
- Daily standups and sprint reviews
Show Answer
Answer: C) Test-driven development and continuous integration
The description matches the TDD cycle (write failing test, make it pass, refactor) and frequent integrations with automated builds and tests (continuous integration). Pair programming and collective code ownership are XP practices too, but they are not mentioned explicitly here. WIP limits and cycle time are Kanban concepts. Daily standups and sprint reviews are Scrum events.
Flashcards: Key Terms and Exam Signals
Flip through these flashcards to reinforce your recall of Kanban, XP, and flow-based agile concepts.
- Kanban board
- A visual representation of work, usually as columns that represent workflow states (for example, Backlog, In Progress, Done), with cards representing work items moving from left to right.
- Work-in-progress (WIP) limit
- A constraint on how many work items may be in a given state (or in the whole system) at one time, used in Kanban to reduce multitasking, expose bottlenecks, and improve flow.
- Cycle time (Kanban)
- The amount of elapsed time it takes for a single work item to move from the start of active work (for example, In Progress) to completion (Done).
- Throughput (Kanban)
- The number of work items completed per unit of time (for example, stories per week), used to understand and forecast delivery capability.
- Extreme Programming (XP)
- An agile approach that emphasizes disciplined software engineering practices such as pair programming, test-driven development, continuous integration, and refactoring to achieve high quality and rapid feedback.
- Pair programming
- An XP practice where two developers work together at one workstation on the same code, frequently switching roles between typing (driver) and reviewing (navigator).
- Test-driven development (TDD)
- An XP practice in which developers write an automated test before writing the production code, then implement just enough code to make the test pass, and finally refactor while keeping tests green.
- Continuous integration (CI)
- An XP-related practice where developers frequently integrate code into a shared repository, triggering automated builds and tests to detect integration issues early.
- Scrum cadence vs Kanban cadence
- Scrum uses fixed-length sprints to structure work; Kanban uses continuous flow, pulling work when capacity is available rather than planning fixed sprint scopes.
- Exam signal for Kanban
- Look for visual boards with WIP limits, continuous pull of work, and metrics like cycle time and throughput, with no emphasis on sprints or Scrum roles.
- Exam signal for XP
- Look for descriptions of pair programming, tests written before code, continuous integration, refactoring, and strong focus on code quality and rapid technical feedback.
Key Terms
- Kanban
- A flow-based method for managing work that emphasizes visualizing work, limiting work-in-progress, and improving flow using metrics such as cycle time and throughput.
- Lead time
- The total elapsed time from when a request is made until the work is delivered.
- Cycle time
- In Kanban, the amount of elapsed time it takes for a single work item to move from the start of active work to completion.
- Throughput
- The number of work items completed per unit of time, used to understand and forecast delivery capacity.
- Refactoring
- Improving the internal structure of existing code without changing its external behavior, to make it easier to understand and modify.
- Product backlog
- An ordered list of everything that is known to be needed in the product, managed by the product owner.
- Flow-based agile
- An agile approach that focuses on continuous movement of work through a system, emphasizing WIP limits and flow metrics rather than fixed-length timeboxes.
- Pair programming
- An XP practice in which two developers work together at one workstation on the same code, frequently switching roles.
- Extreme Programming (XP)
- An agile approach that focuses on disciplined software engineering practices, including pair programming, test-driven development, continuous integration, refactoring, and collective code ownership.
- Continuous integration (CI)
- A practice where developers frequently integrate code into a shared repository, triggering automated builds and tests to detect integration issues early.
- Work-in-progress (WIP) limit
- A constraint on how many work items may be in a given state (or in the whole system) at one time, used in Kanban to improve focus and flow.
- Test-driven development (TDD)
- An XP practice where automated tests are written before the production code, guiding design and ensuring regression safety.