Definition
- SDLC (Software Development Life Cycle) – the overall framework of phases a software product passes through: requirements, design, implementation, testing, deployment, and maintenance.
- Agile – a set of values and principles from the Agile Manifesto for running the SDLC iteratively and incrementally, delivering working software frequently.
- Waterfall – the alternative model that runs SDLC phases once in strict sequence: all requirements, then all design, then all implementation, then all testing.
- Scrum – an Agile framework using fixed-length sprints (usually two weeks) with defined roles (Product Owner, Scrum Master) and ceremonies.
- Kanban – an Agile framework using continuous flow with limits on work in progress.
Think of building National Bank of India's new mobile app. SDLC is the list of stages any construction must go through: figure out what to build, design it, build it, test it, open it to customers, maintain it. Waterfall is like constructing the entire building in one long sequence. Agile is like building and opening one floor at a time, getting customers to use each floor and give feedback before building the next.
Understanding the Concepts
What is SDLC?
SDLC names the fundamental phases that any software effort involves, regardless of methodology. Every real project touches these activities; SDLC is simply the vocabulary and structure for them.
SDLC Phases: 1. Requirements → gather and agree what the system must do 2. Design → architecture, data model, interfaces 3. Implementation → write the code 4. Testing → verify it meets requirements 5. Deployment → release to users 6. Maintenance → fix issues, adapt, eventually retire
package com.bank.planning;
/**
* Example: SDLC phases for the Transfer Service at NBI
*
* 1. Requirements: "Allow customers to transfer up to 10 lakh INR
* between NBI accounts with real-time balance updates."
* 2. Design: REST API, event-driven debit/credit, PostgreSQL ledger.
* 3. Implementation: Spring Boot service, Liquibase migrations.
* 4. Testing: unit tests, integration tests, load tests.
* 5. Deployment: Docker image, Kubernetes rolling update.
* 6. Maintenance: monitoring, bug fixes, feature enhancements.
*/
public class SdlcPhases {
// This class documents the phases for reference
}
What is Agile?
Agile is a set of values and principles from the Agile Manifesto that says: deliver working software in short cycles, welcome change, and favour collaboration over heavy planning. It overlays the same SDLC phases but runs them in many short iterations.
Agile Manifesto 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
Agile iteration (2-week sprint): ┌─────────────────────────────────────────────┐ │ Sprint 1: Account Balance Feature │ │ Requirements → Design → Build → Test → Demo│ │ Deliverable: working balance endpoint │ └─────────────────────────────────────────────┘ ┌─────────────────────────────────────────────┐ │ Sprint 2: Transfer Feature │ │ Requirements → Design → Build → Test → Demo│ │ Deliverable: working transfer endpoint │ └─────────────────────────────────────────────┘
How is Agile different from Waterfall?
| Aspect | Waterfall | Agile |
|---|---|---|
| Phases | Once, sequentially | Many short iterations |
| Feedback | Late (after all phases) | Early (every sprint) |
| Change handling | Expensive, resisted | Welcomed, absorbed next sprint |
| Delivery | One big release at end | Incremental, potentially shippable |
| Risk discovery | Late | Early (every iteration) |
| Documentation | Heavy up front | Just enough, living docs |
| Best for | Fixed requirements | Evolving requirements |
Waterfall: [Requirements]→[Design]→[Build]→[Test]→[Deploy] ──────────────────────────────────────────────→ Feedback at the end only Agile: [R→D→B→T] → [R→D→B→T] → [R→D→B→T] → [R→D→B→T] Sprint 1 Sprint 2 Sprint 3 Sprint 4 Feedback after every sprint
What is Scrum?
Scrum organizes work into fixed-length sprints, usually two weeks, with defined roles and ceremonies.
Scrum framework:
Roles:
Product Owner → prioritizes the backlog
Scrum Master → facilitates, removes blockers
Dev Team → builds the increment
Ceremonies:
Sprint Planning → what to build this sprint
Daily Stand-up → 15 min: what I did, what I will do, blockers
Sprint Review → demo the increment to stakeholders
Retrospective → how to improve the process
Artifacts:
Product Backlog → ordered list of everything needed
Sprint Backlog → items committed for this sprint
Increment → working software at sprint end
package com.bank.agile;
import java.util.List;
import java.util.ArrayList;
public class SprintBacklog {
private final int sprintNumber;
private final List<String> userStories;
public SprintBacklog(int sprintNumber) {
this.sprintNumber = sprintNumber;
this.userStories = new ArrayList<>();
}
public void addStory(String story) {
userStories.add(story);
}
public void printBacklog() {
System.out.println("Sprint " + sprintNumber + " Backlog:");
for (int i = 0; i < userStories.size(); i++) {
System.out.println(" " + (i + 1) + ". " + userStories.get(i));
}
}
public static void main(String[] args) {
SprintBacklog sprint = new SprintBacklog(5);
sprint.addStory("As a customer, I can view my balance");
sprint.addStory("As a customer, I can transfer up to 10L INR");
sprint.addStory("As an admin, I can freeze an account");
sprint.printBacklog();
}
}
Sprint 5 Backlog:
1. As a customer, I can view my balance
2. As a customer, I can transfer up to 10L INR
3. As an admin, I can freeze an account
What is Kanban?
Kanban focuses on continuous flow with limits on work in progress, pulling new work only as capacity frees.
Kanban board: ┌────────────┬────────────┬────────────┬──────────┐ │ Backlog │ In Progress│ Review │ Done │ │ │ (WIP: 3) │ (WIP: 2) │ │ ├────────────┼────────────┼────────────┼──────────┤ │ IBAN migr. │ Transfer │ Balance │ Login │ │ Fraud v2 │ Statement │ Freeze │ Signup │ │ Audit log │ Webhook │ │ Profile │ └────────────┴────────────┴────────────┴──────────┘
When should you NOT use Agile?
Pure Waterfall still fits where requirements are genuinely fixed and change is costly, and many organizations run a hybrid with Agile iterations plus up-front architecture and compliance gates.
Hybrid approach at National Bank of India:
Phase 1: Architecture review + compliance gate (Waterfall-style)
Phase 2: Build in 2-week sprints (Agile)
Phase 3: Security audit + regulatory sign-off (Waterfall-style)
Phase 4: Canary deployment + monitoring (Agile + DevOps)
What are common mistakes?
The most common mistake is adopting Agile ceremonies without the engineering practices that make frequent delivery safe.
# WRONG: Agile ceremonies without CI/CD
Sprints every 2 weeks
But: manual builds, no automated tests, manual deployments
Result: chaos, not agility
# CORRECT: Agile paired with engineering practices
Sprints every 2 weeks
Plus: CI/CD pipeline, automated tests, feature flags, monitoring
Result: safe, frequent, high-quality delivery
What should a senior engineer know?
A senior engineer understands that Agile and SDLC are not competitors: SDLC is the container and Agile is one way to fill it. Agile without CI/CD, automated testing, and DevOps degrades into chaotic frequent change; with them, it delivers the responsiveness the manifesto promises.
Visual Overview
SDLC (the phases):
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ Require │→ │ Design │→ │ Build │→ │ Test │→ │ Deploy │
└──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘
Waterfall (one pass):
[──Require──][──Design──][──Build──][──Test──][──Deploy──]
Agile (many iterations):
[R→D→B→T→D] [R→D→B→T→D] [R→D→B→T→D] [R→D→B→T→D]
Sprint 1 Sprint 2 Sprint 3 Sprint 4
↑ feedback ↑ feedback ↑ feedback
Key Takeaway
SDLC is the set of phases every software project goes through: requirements, design, implementation, testing, deployment, and maintenance. It describes what work must happen. Agile is a how: a set of values and principles for running those phases iteratively, delivering working software in short cycles, welcoming change, and favoring collaboration over heavy planning.
The contrast is sharpest against Waterfall, which runs the phases once sequentially. Waterfall delivers late and handles change poorly; Agile delivers early and absorbs change every sprint. Scrum structures the flow into fixed sprints with roles and ceremonies; Kanban uses continuous flow with WIP limits.
The judgement a senior engineer brings is that Agile only works when paired with CI/CD, automated testing, and DevOps. At National Bank of India, a hybrid approach used Agile sprints for the build with deliberate architecture reviews and compliance gates that the regulator requires.
Remember one sentence: SDLC is the what, Agile is the how, and Agile without CI/CD is just chaos with ceremonies.
---