Agile Scrum

# Agile Scrum

## What is Scrum?

**Scrum:** Agile framework for managing complex projects through iterative development in short cycles (sprints).

### Core Principles
```
Iterative: Work in short cycles (1-4 weeks)
Incremental: Deliver working software each sprint
Collaborative: Cross-functional teams
Adaptive: Respond to change quickly
Transparent: Visible progress and blockers
```

### Scrum vs Waterfall
```
Waterfall:
Requirements → Design → Development → Testing → Deployment
(6-12 months, all at once)

Scrum:
Sprint 1 → Sprint 2 → Sprint 3 → ...
(2 weeks each, continuous delivery)
```

---

## Scrum Roles

### Product Owner (PO)
**Responsibilities:**
- Define product vision
- Manage product backlog
- Prioritize features
- Accept/reject work
- Stakeholder communication

**Key Activities:**
```
- Write user stories
- Prioritize backlog
- Attend sprint planning
- Review sprint demos
- Make business decisions
```

### Scrum Master (SM)
**Responsibilities:**
- Facilitate Scrum ceremonies
- Remove impediments
- Coach team on Scrum
- Protect team from distractions
- Foster continuous improvement

**Key Activities:**
```
- Run daily standups
- Facilitate retrospectives
- Remove blockers
- Shield team from interruptions
- Promote Scrum values
```

**Not a Manager:**
```
❌ Assign tasks
❌ Manage performance
❌ Make technical decisions

✓ Facilitate
✓ Coach
✓ Remove obstacles
```

### Development Team
**Responsibilities:**
- Deliver working software
- Self-organize
- Estimate work
- Commit to sprint goals
- Continuously improve

**Characteristics:**
```
Cross-functional: All skills needed (dev, test, design)
Self-organizing: Decide how to do work
3-9 members: Small enough to be agile
Dedicated: Full-time on one team
```

---

## Scrum Artifacts

### Product Backlog
**Definition:** Prioritized list of all desired features and improvements

**Format:**
```
Priority | User Story                                    | Points | Status
---------|-----------------------------------------------|--------|--------
1        | As a user, I want to login with email         | 5      | Ready
2        | As a user, I want to reset my password        | 3      | Ready
3        | As a user, I want to update my profile        | 8      | Draft
4        | As an admin, I want to view user analytics    | 13     | Draft
```

**Characteristics:**
```
Dynamic: Constantly evolving
Prioritized: Most valuable items at top
Estimated: Story points assigned
Refined: Regularly groomed
```

### Sprint Backlog
**Definition:** Subset of product backlog committed to for current sprint

**Example:**
```
Sprint 15 (Jan 15 - Jan 28)
Goal: Complete user authentication

Stories:
☐ User login with email (5 points)
☐ Password reset (3 points)
☐ Email verification (5 points)
☐ Remember me functionality (3 points)

Total: 16 points
Team velocity: 15-20 points
```

### Increment
**Definition:** Sum of all completed product backlog items at end of sprint

**Criteria:**
```
Done: Meets Definition of Done
Working: Fully functional
Tested: All tests passing
Deployable: Could ship to production
```

---

## Scrum Ceremonies

### Sprint Planning
**When:** First day of sprint
**Duration:** 2-4 hours (for 2-week sprint)
**Attendees:** Entire Scrum team

**Agenda:**
```
Part 1: What will we deliver?
- Review product backlog
- Select stories for sprint
- Define sprint goal

Part 2: How will we do it?
- Break stories into tasks
- Estimate tasks
- Commit to sprint backlog
```

**Output:**
```
✓ Sprint goal
✓ Sprint backlog
✓ Team commitment
```

### Daily Standup
**When:** Every day, same time
**Duration:** 15 minutes (max)
**Attendees:** Development team (+ SM, PO optional)

**Format:**
```
Each team member answers:
1. What did I do yesterday?
2. What will I do today?
3. Any blockers?
```

**Example:**
```
John: "Yesterday I finished the login API. Today I'll work on 
       password reset. No blockers."

Jane: "Yesterday I worked on the UI. Today I'll continue. 
       Blocked on API documentation."

SM: "I'll get you that documentation after standup."
```

**Rules:**
```
✓ Stand up (keeps it short)
✓ Same time, same place
✓ Focus on progress and blockers
✓ Parking lot for detailed discussions

❌ Problem-solving (take offline)
❌ Status reports to manager
❌ Longer than 15 minutes
```

### Sprint Review (Demo)
**When:** Last day of sprint
**Duration:** 1-2 hours
**Attendees:** Scrum team + stakeholders

**Agenda:**
```
1. Review sprint goal
2. Demo completed work
3. Discuss what's done vs not done
4. Review updated product backlog
5. Discuss next steps
```

**Example:**
```
PO: "Our goal was to complete user authentication. Let me show you 
     what we built..."

[Demo of login, password reset, email verification]

Stakeholder: "Great! Can we add social login next sprint?"
PO: "I'll add it to the backlog and prioritize."
```

### Sprint Retrospective
**When:** After sprint review
**Duration:** 1-1.5 hours
**Attendees:** Scrum team only

**Format:**
```
1. What went well?
2. What didn't go well?
3. What will we improve?
```

**Example:**
```
Went Well:
+ Good collaboration between dev and design
+ All stories completed
+ No major blockers

Didn't Go Well:
- Too many meetings interrupted flow
- Unclear requirements on one story
- CI/CD pipeline was slow

Action Items:
→ Block focus time (no meetings 9-12am)
→ Refine stories better in backlog grooming
→ Optimize CI/CD pipeline (assign to John)
```

**Techniques:**
```
- Start/Stop/Continue
- Mad/Sad/Glad
- 4Ls (Liked, Learned, Lacked, Longed for)
- Sailboat (wind/anchor)
```

### Backlog Refinement (Grooming)
**When:** Mid-sprint
**Duration:** 1-2 hours
**Attendees:** Scrum team

**Activities:**
```
- Review upcoming stories
- Add details and acceptance criteria
- Estimate story points
- Split large stories
- Remove obsolete items
```

---

## User Stories

### Format
```
As a [role]
I want [feature]
So that [benefit]
```

### Examples
```
As a user
I want to reset my password
So that I can regain access if I forget it

As an admin
I want to view user analytics
So that I can understand user behavior
```

### Acceptance Criteria
```
User Story: Password reset

Acceptance Criteria:
✓ User can request reset via email
✓ Reset link expires after 24 hours
✓ User can set new password (min 8 chars)
✓ User receives confirmation email
✓ Old password no longer works
```

### INVEST Criteria
```
Independent: Can be developed separately
Negotiable: Details can be discussed
Valuable: Provides value to users
Estimable: Can be estimated
Small: Fits in one sprint
Testable: Can be verified
```

---

## Story Points and Estimation

### Story Points
**Definition:** Relative measure of effort, complexity, and uncertainty

**Not:**
```
❌ Hours or days
❌ Absolute measure
```

**Fibonacci Scale:**
```
1, 2, 3, 5, 8, 13, 21

1 = Trivial (change button text)
3 = Small (add form field)
5 = Medium (new API endpoint)
8 = Large (authentication system)
13 = Very large (payment integration)
21+ = Too large (split into smaller stories)
```

### Planning Poker
**Process:**
```
1. PO reads user story
2. Team discusses and asks questions
3. Each member selects estimate card (secretly)
4. All reveal cards simultaneously
5. Discuss differences (highest and lowest explain)
6. Re-estimate until consensus
```

**Example:**
```
Story: "Add password reset"

Estimates revealed: 3, 5, 5, 8

Discussion:
- Why 3? "Seems straightforward, we've done similar"
- Why 8? "Need to integrate with email service, handle edge cases"

Re-estimate: 5, 5, 5, 5 → Consensus: 5 points
```

---

## Velocity

### Definition
**Velocity:** Average story points completed per sprint

### Calculation
```
Sprint 1: 15 points
Sprint 2: 18 points
Sprint 3: 16 points

Average velocity: (15 + 18 + 16) / 3 = 16.3 points/sprint
```

### Usage
```
Use velocity to:
- Plan sprint capacity
- Forecast release dates
- Track team performance trends

Don't:
❌ Compare teams (different scales)
❌ Use as performance metric
❌ Pressure team to increase velocity
```

---

## Definition of Done (DoD)

### Purpose
**Shared understanding of what "done" means**

### Example DoD
```
A story is done when:
✓ Code written and reviewed
✓ Unit tests written and passing
✓ Integration tests passing
✓ Code merged to main branch
✓ Deployed to staging
✓ Acceptance criteria met
✓ Documentation updated
✓ Product Owner accepted
```

### Levels
```
Story Done: Meets story DoD
Sprint Done: All stories done + sprint goal met
Release Done: All sprints done + production ready
```

---

## Sprint Workflow

### Sprint Cycle (2 weeks)
```
Day 1: Sprint Planning (4 hours)
       - Select stories
       - Define sprint goal
       - Break into tasks

Day 2-9: Development
         - Daily standup (15 min)
         - Work on tasks
         - Update board

Day 5: Backlog Refinement (2 hours)
       - Groom upcoming stories

Day 10: Sprint Review (2 hours)
        - Demo completed work
        
        Sprint Retrospective (1.5 hours)
        - Discuss improvements

Day 11: Start next sprint
```

---

## Scrum Board

### Columns
```
To Do | In Progress | In Review | Done
------|-------------|-----------|-----
Story | Story       | Story     | Story
Story | Task        | Task      | Story
Task  |             |           | Task
```

### Example
```
To Do          | In Progress      | In Review        | Done
---------------|------------------|------------------|-------------
Password reset | Login UI         | Login API        | User signup
Email verify   | Password API     | Email templates  | Database setup
Profile update |                  |                  |
```

### Digital Tools
```
- Jira
- Trello
- Azure DevOps
- Linear
- Asana
```

---

## Common Metrics

### Burndown Chart
```
Story Points Remaining

40 |●
   |  ●
30 |    ●
   |      ●
20 |        ●
   |          ●
10 |            ●
   |              ●
0  |________________●
   Day 1  ...     Day 10

Ideal: Straight line from start to zero
Actual: May vary but should trend down
```

### Velocity Chart
```
Story Points

20 |     ■     ■     ■
   |   ■   ■       ■
15 | ■           ■
   |
10 |
   |_________________________
    S1  S2  S3  S4  S5  S6

Track: Average velocity over time
Goal: Stable, predictable velocity
```

### Cumulative Flow Diagram
```
Stories

40 |           Done
   |         In Review
30 |       In Progress
   |     To Do
20 |
   |
10 |
   |_________________________
    Week 1  Week 2  Week 3

Shows: Work distribution across states
Goal: Smooth flow, no bottlenecks
```

---

## Scaling Scrum

### Multiple Teams
```
Scrum of Scrums:
- Representatives from each team meet
- Discuss dependencies
- Coordinate work
- Remove cross-team blockers
```

### SAFe (Scaled Agile Framework)
```
Team Level: Scrum teams
Program Level: Agile Release Train (ART)
Portfolio Level: Strategic themes
```

### LeSS (Large-Scale Scrum)
```
One product backlog
One Product Owner
Multiple teams
Coordinated sprints
```

---

## Best Practices

### 1. Keep Sprints Consistent
```
✓ Same duration (2 weeks recommended)
✓ Same day of week
✓ Predictable rhythm
```

### 2. Protect the Sprint
```
✓ No scope changes mid-sprint
✓ PO shields team from distractions
✓ Focus on sprint goal
```

### 3. Maintain Sustainable Pace
```
✓ Don't overcommit
✓ Leave buffer for unknowns
✓ Avoid burnout
```

### 4. Embrace Change
```
✓ Adapt based on feedback
✓ Continuously improve
✓ Inspect and adapt
```

### 5. Focus on Value
```
✓ Prioritize high-value features
✓ Deliver working software
✓ Get user feedback early
```

---

## Common Pitfalls

### ❌ Scrum Theater
```
Going through motions without embracing values
- Standups become status reports
- Retrospectives don't lead to change
- Sprint planning is just task assignment
```

### ❌ Scope Creep
```
Adding work mid-sprint
- Breaks sprint commitment
- Reduces predictability
- Frustrates team
```

### ❌ Skipping Ceremonies
```
"We're too busy to do retrospectives"
- Misses improvement opportunities
- Repeats same mistakes
```

### ❌ Treating Scrum Master as Project Manager
```
SM assigns tasks and tracks hours
- Undermines self-organization
- Creates dependency
```

### ❌ Ignoring Definition of Done
```
"It's done except for tests"
- Accumulates technical debt
- Reduces quality
```

---

## Transitioning to Scrum

### Step 1: Training
```
- Scrum fundamentals for all
- Role-specific training
- Certified Scrum Master (CSM)
```

### Step 2: Form Teams
```
- Cross-functional teams
- Assign roles (PO, SM, Dev)
- Co-locate if possible
```

### Step 3: Create Backlog
```
- Gather requirements
- Write user stories
- Prioritize
- Estimate
```

### Step 4: Run First Sprint
```
- Keep it simple
- Focus on learning
- Expect mistakes
```

### Step 5: Inspect and Adapt
```
- Honest retrospectives
- Implement improvements
- Iterate on process
```

---

## Tools and Resources

### Project Management
```
- Jira (most popular)
- Azure DevOps
- Linear
- Trello
- Asana
```

### Estimation
```
- Planning Poker (app or cards)
- Scrum Poker Online
- PlanITpoker
```

### Retrospectives
```
- Retrium
- FunRetro
- Miro
- Metro Retro
```

### Learning
```
- Scrum Guide (official)
- Scrum Alliance
- Scrum.org
- Mountain Goat Software (Mike Cohn)
```

---

## Summary

**Scrum:** Agile framework for iterative development

**Roles:**
- Product Owner (what to build)
- Scrum Master (how to work)
- Development Team (build it)

**Artifacts:**
- Product Backlog (all work)
- Sprint Backlog (sprint work)
- Increment (done work)

**Ceremonies:**
- Sprint Planning (plan sprint)
- Daily Standup (sync daily)
- Sprint Review (demo work)
- Sprint Retrospective (improve)
- Backlog Refinement (prepare backlog)

**Key Concepts:**
- User stories (requirements)
- Story points (estimation)
- Velocity (capacity)
- Definition of Done (quality)
- Sprint (time-box)

**Benefits:**
- Faster time to market
- Higher quality
- Better adaptability
- Improved collaboration
- Continuous improvement

**Success Factors:**
- Committed team
- Empowered Product Owner
- Servant-leader Scrum Master
- Stakeholder support
- Continuous learning