The PMI-ACP exam tests your knowledge of multiple agile methodologies—not just Scrum. This breadth is what distinguishes PMI-ACP from certifications like CSM or PSM, which focus exclusively on Scrum. To pass, you need to understand when and why you'd apply different approaches.
This guide covers each methodology tested on the exam, including core concepts, key practices, and how to recognize which framework applies in scenario questions. For a complete overview of the certification, see our PMI-ACP Certification Guide.
What Is Agile?
Before diving into specific methodologies, it's important to understand that "agile" isn't a single framework—it's a mindset built on shared values and principles.
The Agile Manifesto:
In 2001, seventeen software practitioners created the Agile Manifesto, establishing four core values:
- Individuals and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan
The manifesto doesn't reject the items on the right—it simply values the items on the left more.
The Twelve Principles:
Behind the four values are twelve principles that guide agile practice. These include concepts like delivering working software frequently, welcoming changing requirements, and building projects around motivated individuals. You should know all twelve principles for the PMI-ACP exam.
Agile as umbrella:
Multiple methodologies emerged from these shared values, each emphasizing different aspects. Scrum focuses on roles and time-boxed iterations. Kanban emphasizes flow and visualization. XP prioritizes technical excellence. Lean targets waste elimination. Understanding these distinctions helps you apply the right approach to specific situations.
Scrum
Scrum is the most widely adopted agile framework and receives significant coverage on the PMI-ACP exam. If you've worked in agile environments, you've likely encountered Scrum.
Core concept:
Scrum uses fixed-length iterations called Sprints (typically 2-4 weeks) to deliver potentially shippable product increments. The framework defines specific roles, events, and artifacts that create structure for iterative delivery.
The three roles:
Product Owner
- Owns the Product Backlog
- Prioritizes work based on value
- Represents stakeholders and customers
- Makes decisions about what to build
Scrum Master
- Facilitates Scrum events
- Removes impediments for the team
- Coaches the team on Scrum practices
- Serves as servant leader, not manager
Developers
- Cross-functional team members who do the work
- Self-organize to accomplish Sprint goals
- Collectively responsible for delivery
The five events:
Sprint
- Time-boxed iteration (1-4 weeks, typically 2)
- Contains all other events
- Produces a potentially shippable increment
Sprint Planning
- Team selects work from Product Backlog
- Defines Sprint Goal
- Creates Sprint Backlog
Daily Scrum
- 15-minute daily sync
- Team coordinates work
- Identifies impediments
Sprint Review
- Demonstrates completed work
- Gathers stakeholder feedback
- Updates Product Backlog based on learning
Sprint Retrospective
- Team reflects on the Sprint
- Identifies improvements
- Creates action items for next Sprint
The three artifacts:
Product Backlog
- Ordered list of everything needed in the product
- Owned by Product Owner
- Continuously refined
Sprint Backlog
- Items selected for current Sprint
- Plan for delivering the increment
- Owned by Developers
Increment
- Sum of all completed work
- Must meet Definition of Done
- Potentially releasable
When Scrum applies:
Scrum works well when requirements are complex and likely to change, when the team can work in iterations, and when regular stakeholder feedback is valuable. It's less suited for maintenance work, continuous flow environments, or situations where time-boxing doesn't fit.
PMI-ACP exam tips:
Know the roles, events, and artifacts thoroughly. Understand who owns what (Product Owner owns the backlog, not the Scrum Master). Recognize that the Scrum Master is a servant leader, not a project manager.
Kanban
Kanban takes a fundamentally different approach from Scrum—it focuses on flow rather than iterations. There are no sprints, no prescribed roles, and no required ceremonies.
Core concept:
Kanban visualizes work flowing through a system and uses Work in Progress (WIP) limits to optimize that flow. The goal is smooth, continuous delivery rather than batch delivery at iteration boundaries.
The four foundational principles:
- Start with what you do now (no big transformation required)
- Agree to pursue incremental, evolutionary change
- Respect current roles and responsibilities
- Encourage acts of leadership at all levels
The six core practices:
Visualize the workflow
- Use a Kanban board to make work visible
- Columns represent stages (To Do, In Progress, Done, or more detailed)
- Cards represent work items
Limit Work in Progress (WIP)
- Set maximum items allowed in each stage
- Prevents overloading and multitasking
- Forces completion before starting new work
Manage flow
- Monitor how work moves through the system
- Identify and address bottlenecks
- Track metrics like cycle time and throughput
Make policies explicit
- Define rules for how work moves between stages
- Create shared understanding of "done" for each stage
- Document any agreements the team follows
Implement feedback loops
- Regular review of the system's performance
- Retrospectives and metrics review
- Customer feedback integration
Improve collaboratively, evolve experimentally
- Use data to guide improvements
- Make small changes and measure results
- Continuous improvement mindset
Key Kanban metrics:
Lead time: Total time from request to delivery
Cycle time: Time from work starting to completion
Throughput: Number of items completed per time period
Cumulative Flow Diagram (CFD): Visual showing work distribution across stages over time
When Kanban applies:
Kanban excels in environments with continuous incoming work (support, maintenance, operations), where batch delivery doesn't make sense, or when teams need to improve flow without major process changes. It's also used alongside Scrum in hybrid approaches.
PMI-ACP exam tips:
Understand WIP limits and why they matter—questions often present scenarios with too much work in progress. Know how to read a cumulative flow diagram. Recognize that Kanban doesn't prescribe iterations or roles.
Lean
Lean originated in manufacturing (Toyota Production System) and was later adapted for software development. It focuses relentlessly on eliminating waste and maximizing value delivery.
Core concept:
Every activity either adds value for the customer or is waste. Lean seeks to identify and eliminate waste while optimizing the flow of value from concept to customer.
The seven wastes of software development:
Partially done work
- Unfinished features sitting in queues
- Code written but not tested or deployed
Extra features
- Building functionality customers don't need
- Gold-plating beyond requirements
Relearning
- Losing knowledge due to handoffs or delays
- Failing to document decisions
Handoffs
- Transferring work between people or teams
- Each handoff loses information and adds delay
Task switching
- Context switching between multiple projects
- Multitasking that reduces efficiency
Delays
- Waiting for approvals, resources, or dependencies
- Queues between process stages
Defects
- Bugs and errors requiring rework
- Quality issues caught late in the process
Key Lean concepts:
Value stream mapping
- Visualize the entire flow from concept to delivery
- Identify where value is added and where waste occurs
- Target waste for elimination
Pull systems
- Work is pulled when capacity exists
- Prevents overproduction and excess inventory
- Contrasts with push systems that create work regardless of capacity
Kaizen
- Continuous improvement through small changes
- Everyone contributes to improving the process
- Incremental rather than revolutionary change
When Lean applies:
Lean principles apply broadly across agile approaches. Value stream mapping helps any team identify bottlenecks. Waste identification improves any process. Many teams combine Lean thinking with Scrum or Kanban practices.
PMI-ACP exam tips:
Memorize the seven wastes—questions often describe scenarios and ask you to identify the waste. Understand value stream mapping and how it reveals improvement opportunities. Know that Lean emphasizes eliminating waste, not just adding practices.
Extreme Programming (XP)
XP focuses on technical excellence and engineering practices. While Scrum addresses process and Lean addresses waste, XP addresses how to write better software.
Core concept:
XP uses specific technical practices to enable sustainable development, rapid feedback, and high-quality code. It emphasizes doing simple things well and getting rapid feedback on results.
The five XP values:
- Communication
- Simplicity
- Feedback
- Courage
- Respect
Key XP practices:
Pair programming
- Two developers work together at one workstation
- One writes code, one reviews in real-time
- Roles rotate frequently
- Improves code quality and spreads knowledge
Test-Driven Development (TDD)
- Write tests before writing code
- Red-green-refactor cycle
- Tests define expected behavior
- Code is written to pass tests
Continuous Integration
- Integrate code changes frequently (multiple times daily)
- Automated builds and tests
- Catch integration issues early
Refactoring
- Continuously improve code structure
- Without changing external behavior
- Keeps codebase maintainable
Simple design
- Build only what's needed now
- Avoid speculative complexity
- Easier to change later
Collective code ownership
- Anyone can modify any code
- No individual ownership of modules
- Spreads knowledge across team
Small releases
- Release frequently in small increments
- Get feedback quickly
- Reduce risk of large deployments
On-site customer
- Customer representative available to the team
- Answers questions quickly
- Provides immediate feedback
When XP applies:
XP practices shine when code quality and technical debt are concerns, when requirements change frequently and code must be adaptable, or when teams want to improve their engineering discipline. Many teams adopt selected XP practices (like TDD or pair programming) without adopting the full methodology.
PMI-ACP exam tips:
Know the specific practices and what each accomplishes. Understand that TDD means tests come first, then code. Recognize that XP emphasizes technical practices more than process practices.
Other Methodologies
The PMI-ACP exam may include questions on additional methodologies, though they're tested less heavily than Scrum, Kanban, Lean, and XP.
Crystal:
Crystal is a family of methodologies created by Alistair Cockburn, scaled by team size and criticality:
- Crystal Clear (small teams, low criticality)
- Crystal Yellow, Orange, Red (progressively larger and more critical)
Key concepts:
- People-focused—emphasizes individuals over process
- Methodology tailoring—adapt the approach to context
- Frequent delivery and reflective improvement
- Osmotic communication (team members absorb information by proximity)
DSDM (Dynamic Systems Development Method):
DSDM is a business-focused agile framework:
- Emphasizes business value and active user involvement
- Uses MoSCoW prioritization (Must have, Should have, Could have, Won't have)
- Time-boxed and iterative
- Includes formal project phases and governance
FDD (Feature-Driven Development):
FDD organizes work around features:
- Feature-centric planning and tracking
- Emphasis on domain modeling
- Short iterations (typically 2 weeks)
- Five core processes: develop overall model, build feature list, plan by feature, design by feature, build by feature
PMI-ACP exam tips:
You don't need deep expertise in these methodologies. Know their distinguishing characteristics—Crystal's people focus and tailoring, DSDM's MoSCoW prioritization, FDD's feature-centric approach. Recognize them if described in scenarios.
Comparing Methodologies
Understanding when to apply each methodology is as important as knowing the methodology itself.
Scrum vs Kanban
Scrum
- Time-boxed iterations (Sprints)
- Prescribed roles (PO, SM, Developers)
- Batch delivery at Sprint end
- Best for: New product development, complex requirements
Kanban
- Continuous flow, no iterations
- No prescribed roles
- Continuous delivery when ready
- Best for: Maintenance, support, operations, continuous improvement
When methodology questions appear:
Exam scenarios may describe a situation and ask which approach fits best. Look for clues:
- "The team receives unpredictable support requests" → Kanban
- "The team delivers features every two weeks" → Scrum
- "The team wants to reduce bugs and technical debt" → XP practices
- "The team needs to identify bottlenecks in their process" → Lean/value stream mapping
Hybrid approaches:
In practice, many teams combine elements from multiple methodologies. Scrumban blends Scrum's structure with Kanban's flow optimization. Teams often layer XP practices onto Scrum. Lean thinking applies across all approaches. The exam may present hybrid scenarios—focus on which practice or principle applies to the specific problem described.
Next Steps
Understanding multiple methodologies prepares you for the breadth of the PMI-ACP exam. As you study, practice identifying which methodology applies to different scenarios—this skill translates directly to exam success.
For detailed coverage of the exam's seven domains, see PMI-ACP Exam Domains. To build your study schedule around this content, review our PMI-ACP Study Plan.
Ready to test your methodology knowledge? Practice PMI-ACP questions covering all methodologies and domains, or download the PM Drills app to study anywhere.
