Popular Software Development Methodologies

🔥 Quick overview

• Agile — mindset + principles (iterative, customer feedback).

• Scrum — Agile ka popular framework (sprints, defined roles).

• Kanban — Flow-based method (visual board, WIP limits, continuous delivery).

• DevOps — Culture + practices to connect Dev & Ops (automation, CI/CD, monitoring).

---

1) Agile — deep dive

Kya hai: Iterative, incremental approach focused on customer value and fast feedback.
Principles (short): individuals & interactions, working software, customer collaboration, respond to change.

Practices:

• Iterations (1–4 weeks) — har iteration me working increment.

• User stories, backlog grooming, prioritization.

• Continuous integration of feedback.

Artifacts: Product Backlog, Iteration Backlog, Increment (working product).
Metrics: Velocity (story points / sprint), Lead time, Customer satisfaction (NPS).
When use karein: Requirements dynamic ho, frequent releases chahte ho, customer feedback important ho.
Pitfalls: Poor backlog grooming, no definition of done, lack of stakeholder involvement.

---

2) Scrum — deep dive (Agile ka framework)

Core roles:

• Product Owner (PO) — backlog owner, prioritization, stakeholder liaison.

• Scrum Master — process coach, impediment remover.

• Development Team — cross-functional team delivering increment.

Events (ceremonies):

• Sprint (time-boxed, usually 2 wks)

• Sprint Planning (what + how)

• Daily Scrum (15 min standup)

• Sprint Review (demo to stakeholders)

• Sprint Retrospective (process improvements)

Artifacts: Product Backlog, Sprint Backlog, Increment, Burndown Chart.

How Sprint flows (simple):

1. PO prioritizes backlog → 2. Sprint planning → 3. Team delivers increment → 4. Review & Retrospective.

Best for: Teams that can work in time-boxed cadence, clear increment goals.
Common issues: Overcommitting, ignoring retros, PO absent/weak.

---

3) Kanban — deep dive

Kya hai: Visual work-management system; focus on continuous flow and limiting Work In Progress (WIP).
Core concepts:

• Kanban Board with columns (Backlog / To Do → In Progress → Review → Done).

• WIP Limits per column / team member.

• Pull system: team pulls work when capacity available (not pushed).

Metrics:

• Cycle Time (time to finish a card),

• Lead Time (from request to delivery),

• Throughput (items completed per time slice).

When use karein: Continuous delivery, maintenance/support teams, unpredictable priorities, seek process improvement with minimal disruption.
Advantages: Flexible, incremental adoption, clear bottleneck visibility.
Pitfalls: No explicit cadences may reduce stakeholder alignment; over-large WIP limits.

---

4) DevOps — deep dive

Kya hai: Culture + practices + tools to deliver software faster and reliably by automating build, test, release and operations; close feedback loops.

Core pillars:

• CI/CD (Continuous Integration / Continuous Delivery or Deployment)

• Infrastructure as Code (IaC) (Terraform, CloudFormation)

• Monitoring & Observability (logs, metrics, traces)

• Automation (testing, deploys)

• Collaboration & shared responsibility

DORA metrics (important):

1. Deployment Frequency

2. Lead Time for Changes (commit → deploy)

3. Change Failure Rate (failed deployments)

4. MTTR (mean time to recovery)

Practices & tools (examples):

• VCS: Git; CI: GitHub Actions, Jenkins, GitLab CI.

• Containers: Docker; Orchestration: Kubernetes.

• IaC: Terraform, Ansible.

• Monitoring: Prometheus, Grafana, ELK, Sentry.

• Security: integrate scanners (SAST/DAST), secret management.

When use karein: Need rapid delivery, high reliability, frequent releases, ops automation.
Pitfalls: Automating bad processes, neglecting culture & skill-building, poor observability.

---

Comparative Chart (table — quick at-a-glance)

Aspect	Agile	Scrum	Kanban	DevOps
Focus	Iterative delivery & change	Sprint-based delivery	Continuous flow & WIP limits	Automation, CI/CD, ops+dev collaboration
Cadence	Iterations (flexible)	Fixed sprints (1–4w)	Continuous	Continuous delivery (pipeline)
Roles	Flexible	PO, SM, Team	No fixed roles	Cross-functional (Dev + Ops)
Artifacts	Backlogs	Product/Sprint Backlog, Increment	Kanban Board	Pipelines, IaC repos, runbooks
Best for	Variable requirements	Feature delivery in cadences	Maintenance, ops, continuous fixes	High release velocity & reliability
Metrics	Velocity, lead time	Velocity, burndown	Cycle time, throughput	DORA metrics, MTTR

---

Charts (textual diagrams you can copy as a visual)

A) Agile Iteration Loop

      ┌──────┐
      │Plan  │
      └──┬───┘
         ▼
      ┌──────┐
      │Build │
      └──┬───┘
         ▼
      ┌──────┐
      │Test  │
      └──┬───┘
         ▼
      ┌──────┐
      │Review│ ← Feedback to Plan
      └──┬───┘
         ▼
      ┌──────┐
      │Retro │
      └──┴───┘

B) Scrum Sprint Cycle (2-week example)

Backlog ---> Sprint Planning ---> Sprint (2w)
                  │
             Daily Standup
                  │
            Development & Testing
                  │
           Sprint Review (demo)
                  │
        Sprint Retrospective -> Improvements

C) Kanban Board (example)

To Do (WIP limit 5) | In Progress (WIP limit 3) | Review | Done
[Card-1]             [Card-4]                   [Card-7]  [Card-9]
[Card-2]             [Card-5]                   [Card-8]
[Card-3]             [Card-6]

(Enforce WIP limits; pull when capacity available.)

D) DevOps CI/CD Pipeline

Developer Commit (Git) 
     ↓
CI Server (Build + Unit Tests)
     ↓
Automated Integration Tests
     ↓
Artifact Repo (versioned build)
     ↓
CD to Staging (Automated Acceptance + Performance Tests)
     ↓
Approval / Automated Deploy
     ↓
Production → Monitoring & Alerts → Feedback to Dev

---

Practical guidance — when to pick what

• Startups with rapid feature changes: Agile + Scrum (short sprints) + DevOps pipelines.

• Support / operations teams: Kanban (continuous flow).

• Large orgs with many teams: Scrum for teams + DevOps for delivery + Kanban for Ops.

• Regulated or safety-critical: Scrum/Agile with strict definition of done + extended testing + DevOps but slow, gated CD.

---

KPIs & What to track (actionable)

• For Agile/Scrum: Sprint velocity, sprint burndown, release predictability, defect escape rate.

• For Kanban: Cycle time, lead time, throughput, WIP.

• For DevOps: DORA metrics (deploy frequency, lead time for changes, change failure rate, MTTR), availability, error budgets.

---

Adoption Roadmap (practical 6-step)

1. Assess current process & pain points.

2. Choose a pilot team & methodology (Scrum or Kanban).

3. Train team + define minimal tooling (Git, CI server, board).

4. Implement CI first (automated build + unit tests).

5. Add CD gradually (staging → automated tests → production).

6. Measure DORA/Agile metrics → iterate improvements.

---

Common tools cheat-sheet

• Planning & Boards: Jira, Trello, Azure Boards, GitHub Projects

• CI/CD: Jenkins, GitHub Actions, GitLab CI, CircleCI

• Containers/Orchestration: Docker, Kubernetes

• IaC: Terraform, CloudFormation, Ansible

• Monitoring: Prometheus, Grafana, ELK/Elastic, Datadog, Sentry

---

Quick case example (practical)

Feature: Payment gateway integration in e-commerce.

• Scrum: PO writes stories; sprint planning picks payment story; devs implement in sprint; CI runs tests; Review demo; deploy via CD.

• Kanban: Card flows from ToDo → In Progress → Review → Done; team pulls when free; smaller, continuous releases.

• DevOps view: Pipeline builds artifact, runs security scans, deploys to staging, runs integration tests, deploys to prod with monitoring.

---

Visual chart / image — ready-to-create layout (exact steps for Canva / Draw.io)

One-page infographic idea:

• Top header: “Agile, Scrum, Kanban, DevOps — Comparison & When to Use”

• Left column: short Agile description + iterative loop icon

• Middle-left: Scrum box with roles, ceremonies, sprint cycle mini-diagram

• Middle-right: Kanban box with board example + WIP limits + metrics

• Right column: DevOps pipeline vertical flow with CI → CD → Monitor, plus DORA metrics icons

• Footer: “When to choose” 3-row table (Startup / Ops / Large org) with icons.

Colors suggestion: Agile/Scrum — light blue; Kanban — light green; DevOps — light orange.
Fonts: Bold headers, monospace for small code/diagram labels.
Icons: sprint (clock), board (cards), pipeline (gear), monitor (eye).