Think about how a food-delivery app like the ones on your phone gets built. The company did not write a 500-page specification in 2015, code for three years, and release one perfect app. They released something small, watched how people used it, and changed it every couple of weeks: new payment options, live tracking, a "repeat last order" button. Many of those features were not even imagined when the project started.
The models we have studied so far, Waterfall Model, Spiral Model and V-Model, are plan-driven: they rely on considerable planning and documentation (up front in Waterfall and V-Model, loop by loop in Spiral) and try to control change. That works when the problem is stable. But for most modern software, the market, the users and even the technology change faster than a big plan can be written. Agile is the response to that reality.
Agile is a family of software development approaches based on the values and principles of the Agile Manifesto (2001). Agile teams deliver working software in short iterations, collaborate closely with customers, and welcome changing requirements, using frequent feedback to decide what to build next.
Agile is not one specific process. It is a mindset (a set of values and principles). Concrete frameworks such as Scrum, Extreme Programming (XP) and Kanban are ways of putting that mindset into practice; we study them in the chapters Scrum and Kanban & Extreme Programming.
The Intuition: GPS vs a Printed Route Map
A printed route map is like Waterfall: you plan the whole journey before leaving, and if a road is closed, the map does not help. A GPS app is like Agile: it has a destination, it plans a route, but it re-checks your position every few seconds and re-plans whenever something changes. It does not plan less; it plans continuously.
Agile teams work the same way: a clear goal, short steps, and a check after every step (a working piece of software shown to real users) to decide the next step.
Why Agile Appeared
Through the 1990s, many teams found heavyweight, document-driven processes slow and frustrating. Several "lightweight" methods grew up independently: Scrum, Extreme Programming, DSDM, Crystal, Feature-Driven Development and others. In February 2001, seventeen practitioners from these different schools met at Snowbird, Utah, and agreed on what their methods had in common. The result was the Manifesto for Agile Software Development.
The problems they were reacting to:
Requirements changed during long projects, so the delivered product was out of date on arrival.
Customers saw working software only at the end, when changes were most expensive.
Teams spent large amounts of effort on documents that few people read.
Big-bang integration and testing at the end produced painful surprises.
The Agile Manifesto: Four Values
The manifesto is short. Its core is four value statements:
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 sentence right after them is the one most people forget: while there is value in the items on the right, the signatories value the items on the left more. Agile does not say "no processes", "no documentation", "no contracts" or "no plans". It says that when you must choose, the left side wins.
Value | What it means in practice | What it does NOT mean |
|---|---|---|
Individuals and interactions over processes and tools | A five-minute conversation beats a ticket that bounces between teams for a week. | No process at all. |
Working software over comprehensive documentation | Progress is measured by software that runs, not by pages written. | No documentation. Useful documents (API docs, user guides, key decisions) are still written. |
Customer collaboration over contract negotiation | The customer is a partner who gives feedback throughout. | No contracts. |
Responding to change over following a plan | Plans are updated when new information arrives. | No planning. Agile teams plan often, just in smaller pieces. |
The Twelve Principles (in Plain Words)
The manifesto is backed by twelve principles. Here they are paraphrased in simple language, grouped by theme.
Customer and value
1. The top priority is to satisfy the customer through early and continuous delivery of valuable software.
2. Welcome changing requirements, even late in development, because responding to change gives the customer a competitive advantage.
3. Deliver working software frequently, every couple of weeks to a couple of months, preferring the shorter timescale.
4. Business people and developers work together daily throughout the project.
People and teams
5. Build projects around motivated individuals; give them the environment and support they need, and trust them.
6. Face-to-face conversation is the most efficient and effective way to share information within a team.
Measuring progress and pace
7. Working software is the primary measure of progress.
8. Agile processes promote sustainable development: sponsors, developers and users should be able to keep a constant pace indefinitely (no endless overtime).
Quality and simplicity
9. Continuous attention to technical excellence and good design improves agility.
10. Simplicity, the art of maximizing the amount of work not done, is essential.
11. The best architectures, requirements and designs emerge from self-organizing teams.
Improvement
12. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behaviour.
Principle 7 is the most quoted in exams: in Agile, progress is measured by working software, not by documents completed or hours spent.
How an Agile Project Flows
Product vision
|
v
+-------------------------------+
| Ordered list of work (backlog)| <---- new ideas, feedback, changes
+-------------------------------+ ^
| pick the most valuable items |
v |
+-------------------------------+ |
| Iteration (1 to 4 weeks) | |
| plan -> design -> code -> | |
| test -> integrate (all of | |
| these happen INSIDE it) | |
+-------------------------------+ |
| |
v |
Working, tested increment --> demo / release --> feedback
|
v
Team reflects and improves its way of working, then next iterationCompare this with Waterfall. In Waterfall, the whole project passes once through requirements → design → code → test. In Agile, every iteration passes through all those activities for a small slice of features. This idea of repeating and growing was introduced in Iterative & Incremental Models; Agile adds short, fixed-length iterations, close customer collaboration and a strong focus on people.
Time-boxing: flipping the iron triangle
Every project juggles scope, time and cost. Traditional plan-driven projects usually fix scope (the requirements document) and then estimate the time and cost needed, which often slip. Agile usually fixes time and cost (a fixed iteration length and a stable team) and lets scope vary: the team delivers the most valuable features that fit, and lower-priority features wait.
Plan-driven Agile
FIXED: Scope FIXED: Time, Cost (team)
ESTIMATED: Time, Cost ESTIMATED: Scope (what fits)Common Agile Practices
None of these is required by the manifesto itself, but they are very widely used.
User stories
Requirements are often written as short user stories from the user's point of view, commonly in this template:
As a <type of user>, I want <some goal> so that <some benefit>.
Example:
As a hostel student, I want to see today's mess menu on my phone
so that I can decide whether to eat in the mess or order outside.
Acceptance criteria:
- Given it is before 8 PM, when I open the app, then I see today's
breakfast, lunch and dinner menu.
- Given the menu has not been uploaded, when I open the app, then I
see "Menu not available yet".A good story is often checked with the INVEST checklist: Independent, Negotiable, Valuable, Estimable, Small, Testable. The story card is deliberately short; the details come from conversation with the customer and are confirmed by the acceptance criteria (the "3 Cs": Card, Conversation, Confirmation).
Relative estimation and story points
Instead of estimating in hours, many teams estimate relative size in story points, often on a Fibonacci-like scale (1, 2, 3, 5, 8, 13, ...). The gaps widen as numbers grow because bigger work is more uncertain. In planning poker, each team member reveals an estimate card at the same time; big differences trigger a discussion, which often uncovers hidden assumptions.
Velocity and forecasting
Velocity is the number of story points a team completes per iteration. It is used by the team to forecast, not to compare teams (story points are not comparable across teams).
Worked Example: Forecasting with Velocity
A team's last three iterations completed 21, 18 and 24 points. The remaining backlog is 168 points. Iterations are two weeks long.
Step 1: Average velocity = (21 + 18 + 24) / 3 = 63 / 3 = 21 points per iteration.
Step 2: Likely number of iterations = 168 / 21 = 8 iterations (about 16 weeks).
Step 3: A range, not a single date. At the best observed velocity (24): 168 / 24 = 7 iterations. At the worst (18): 168 / 18 = 9.33, which rounds up to 10 iterations, since a partial iteration still has to be run. So the honest answer is "7 to 10 iterations, most likely 8".
import math
velocities = [21, 18, 24] # story points completed in last 3 iterations
remaining_backlog = 168 # story points still to do
avg = sum(velocities) / len(velocities)
likely = math.ceil(remaining_backlog / avg)
best = math.ceil(remaining_backlog / max(velocities))
worst = math.ceil(remaining_backlog / min(velocities))
print(f"Average velocity : {avg:.1f} points/iteration")
print(f"Likely forecast : {likely} iterations")
print(f"Range : {best} to {worst} iterations")
print(f"With 2-week iterations: about {likely * 2} weeks")Output:
Average velocity : 21.0 points/iteration
Likely forecast : 8 iterations
Range : 7 to 10 iterations
With 2-week iterations: about 16 weeksAnd because the backlog keeps changing (new stories added, low-value ones dropped), the forecast is recalculated every iteration. That is "responding to change over following a plan" in numbers.
Other common practices
Short daily coordination meeting (stand-up).
Demo / review of working software at the end of each iteration.
Retrospective to improve the team's way of working.
Continuous integration, automated testing, test-driven development, pair programming (covered with XP in Kanban & Extreme Programming and with automation in DevOps & CI/CD).
Cross-functional teams that have all the skills needed to deliver a feature end to end.
The Agile Family
Approach | Core idea in one line |
|---|---|
Scrum | A lightweight framework of fixed-length Sprints with defined accountabilities, events and artifacts (next chapter). |
Extreme Programming (XP) | Engineering practices taken to the extreme: pair programming, test-first development, continuous integration, small releases. |
Kanban | Visualize work on a board, limit work in progress, and manage flow continuously rather than in iterations. |
Lean Software Development | Apply lean manufacturing ideas: eliminate waste, deliver fast, build quality in. |
Feature-Driven Development (FDD) | Model the domain, then build and deliver feature by feature. |
DSDM | Fixed time and cost with prioritised scope using MoSCoW (Must, Should, Could, Won't have). |
Crystal | A family of methods whose formality scales with team size and project criticality. |
For very large organizations, scaling frameworks such as SAFe and LeSS try to coordinate many Agile teams; they are beyond the scope of this tutorial.
Agile vs Traditional (Plan-Driven) Development
Aspect | Plan-driven (e.g. Waterfall, V-Model) | Agile |
|---|---|---|
Requirements | Defined fully up front, changes controlled | Evolve; change is welcomed |
Delivery | One big release at the end | Frequent small releases of working software |
Customer involvement | Mainly at start and end | Continuous |
Measure of progress | Phases and documents completed | Working software |
Testing | A separate later phase | Continuous, inside every iteration |
Documentation | Comprehensive | Just enough, valued but secondary |
Team structure | Specialist groups, hand-offs | Small, cross-functional, self-organizing |
Fixed vs variable | Scope fixed; time and cost estimated | Time and cost fixed per iteration; scope varies |
Risk of building the wrong thing | Discovered late | Discovered within weeks |
Advantages and Limitations
Advantages
Early and frequent value: users get useful features within weeks.
Handles changing requirements gracefully.
Fast feedback reduces the risk of building the wrong product.
Continuous testing and integration improve quality.
Visible progress builds trust with the customer.
Teams that own their work tend to be more motivated.
Limitations
Needs an available, engaged customer (or a representative); without one, feedback dries up.
Harder to give a fixed total price and date at the start, which complicates some contracts.
Less up-front documentation can hurt if the team changes or if regulators require detailed records (this must be planned for deliberately).
Works best with small, co-located or well-connected teams; scaling to hundreds of people needs extra structure.
Requires skilled, disciplined developers; "Agile" without engineering practices often turns into chaos.
When plan-driven may still be better
When requirements are stable and well understood, when safety regulation demands extensive up-front analysis and documentation, or when the customer cannot participate regularly, a plan-driven approach (or a hybrid) can be more appropriate. Sommerville makes the point that most real projects combine plan-driven and agile elements; the question is the balance, not a religious choice.
Common Mistakes
"Agile means no documentation." The manifesto values working software more, not documentation never.
"Agile means no planning." Agile teams plan at several levels (release, iteration, day), just in smaller, more frequent pieces.
Calling Agile a process or framework. Agile is a set of values and principles; Scrum, XP and Kanban are the frameworks/methods.
Using velocity to compare teams or judge individuals. Story points are relative to each team; comparing them creates gaming, not productivity.
Short iterations that end with "almost done" work. An iteration should end with working, tested software, otherwise it is just Waterfall in small pieces.
Rounding an iteration forecast down. 9.33 iterations means 10 iterations of work, not 9.
GATE and Interview Questions
State the four values of the Agile Manifesto.
Individuals and interactions over processes and tools; working software over comprehensive documentation; customer collaboration over contract negotiation; responding to change over following a plan.
According to the Agile principles, what is the primary measure of progress?
Working software.
Does Agile reject documentation?
No. The manifesto states that the items on the right (such as comprehensive documentation) still have value; the items on the left are valued more. Agile teams write documentation that is genuinely useful.
What does INVEST stand for?
Independent, Negotiable, Valuable, Estimable, Small, Testable: a checklist for good user stories.
A team's velocities are 30, 26 and 28 points. The backlog has 196 points. Estimate the number of iterations.
Average velocity = 84 / 3 = 28. Iterations = 196 / 28 = 7. Range: 196 / 30 = 6.53 → 7 at best; 196 / 26 = 7.54 → 8 at worst. So about 7 iterations, possibly 8.
How does Agile treat the scope–time–cost triangle differently from Waterfall?
Waterfall typically fixes scope and estimates time and cost. Agile typically fixes time (iteration length) and cost (a stable team) and lets scope vary, delivering the highest-value items first.
Name three Agile methods or frameworks.
Any three of: Scrum, Extreme Programming (XP), Kanban, Lean Software Development, Feature-Driven Development, DSDM, Crystal.
Summary
Agile is a mindset defined by the Agile Manifesto (2001): 4 values and 12 principles.
Values: individuals and interactions, working software, customer collaboration, responding to change, each valued more than (not instead of) its counterpart.
Work happens in short iterations, each producing working, tested software; feedback drives the next iteration.
Agile usually fixes time and cost and lets scope vary.
Common practices: user stories (INVEST), story points, velocity-based forecasting, stand-ups, reviews, retrospectives, continuous integration.
Frameworks that implement Agile include Scrum, XP, Kanban, Lean, FDD, DSDM and Crystal.
Agile needs an engaged customer and disciplined engineering; plan-driven or hybrid approaches still suit some projects.
The most widely used way to put Agile into practice is Scrum. In the next chapter, Scrum, we will go through its accountabilities, events and artifacts exactly as defined in the official Scrum Guide.