Study smarter with Fiveable
Get study guides, practice questions, and cheatsheets for all your subjects. Join 500,000+ students with a 96% pass rate.
Agile methodology isn't just a buzzword—it's the foundation of modern software development and design strategy. When you're tested on Agile principles, you're being evaluated on your understanding of iterative development, adaptive planning, cross-functional collaboration, and continuous delivery. These frameworks represent different solutions to the same core challenge: how do you build software that actually meets user needs in a constantly changing environment?
Don't fall into the trap of memorizing framework names and their features in isolation. The real exam value comes from understanding why each framework exists and what problem it solves. Whether you're comparing Scrum's structured sprints to Kanban's continuous flow, or explaining when to scale with SAFe versus LeSS, you need to connect each framework to its underlying philosophy. Know the mechanism, not just the method.
These frameworks organize work into time-boxed cycles that create predictable rhythms for planning, building, and reviewing. The core principle: constrain time to force prioritization and enable regular feedback loops.
Compare: Scrum vs. XP—both use iterations and value customer feedback, but Scrum focuses on process and roles while XP emphasizes technical practices and code quality. If an exam question asks about improving software reliability, XP's TDD and pair programming are your go-to examples.
Rather than fixed iterations, these frameworks optimize for continuous delivery and workflow efficiency. The core principle: visualize work, limit bottlenecks, and let value flow to customers without artificial time boundaries.
Compare: Kanban vs. Lean—Kanban is a specific visual method for managing flow, while Lean is a broader philosophy about eliminating waste. Kanban boards are a tool; Lean thinking is the strategy behind using them effectively.
These frameworks prioritize team dynamics, stakeholder relationships, and sustainable pace over rigid processes. The core principle: software is built by people, so optimize for human factors first.
Compare: Crystal vs. ASD—both prioritize adaptability and people, but Crystal offers a family of scaled approaches based on project characteristics, while ASD provides a philosophical framework for navigating uncertainty. Crystal asks "what size is your project?" while ASD asks "how do you respond to change?"
These frameworks extend beyond development sprints to address project initiation, feasibility, and long-term maintenance. The core principle: Agile thinking should govern the entire project lifecycle, not just the coding phase.
Compare: DSDM vs. Scrum—both use timeboxing and iterative delivery, but DSDM explicitly covers pre-development phases (feasibility, foundations) and post-delivery maintenance. Choose DSDM examples when discussing enterprise project governance.
When Agile needs to work across multiple teams, products, or organizational levels, these frameworks provide coordination structures. The core principle: maintain Agile values while adding just enough structure to synchronize large-scale efforts.
Compare: SAFe vs. LeSS—both scale Agile to large organizations, but SAFe adds significant structure and new roles while LeSS maintains Scrum's minimalism. SAFe suits organizations wanting detailed governance; LeSS suits those wanting to scale without bureaucracy. FRQ tip: if asked about trade-offs in scaling, contrast these two directly.
| Concept | Best Examples |
|---|---|
| Time-boxed iterations | Scrum, XP, FDD |
| Continuous flow | Kanban, Lean |
| Technical practices | XP (TDD, pair programming, CI) |
| Visual management | Kanban, Lean (value stream mapping) |
| People-first philosophy | Crystal, ASD |
| Full lifecycle coverage | DSDM |
| Enterprise scaling | SAFe, LeSS |
| Waste elimination | Lean, Kanban (WIP limits) |
Which two frameworks both use iterations but differ in their primary focus—one on process roles and one on technical practices? What specific practices distinguish them?
If a team is experiencing bottlenecks and wants to visualize workflow without committing to fixed sprints, which framework would you recommend and why?
Compare and contrast SAFe and LeSS: What problem do both solve, and what fundamental trade-off distinguishes their approaches?
A project requires Agile practices from initial feasibility assessment through post-launch maintenance. Which framework explicitly addresses this full lifecycle, and what technique does it use to manage scope?
An FRQ asks you to explain how Agile frameworks handle uncertainty differently. Using ASD and Scrum as examples, describe their contrasting philosophies toward change and unpredictability.