Agile Scrum

What is Scrum?

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

Core Principles

code

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

code

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:

code

- 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:

code

- Run daily standups
- Facilitate retrospectives
- Remove blockers
- Shield team from interruptions
- Promote Scrum values

Not a Manager:

code

❌ 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:

code

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:

code

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:

code

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:

code

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:

code

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:

code

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:

code

✓ Sprint goal
✓ Sprint backlog
✓ Team commitment

Daily Standup

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

Format:

code

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

Example:

code

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:

code

✓ 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:

code

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:

code

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:

code

1. What went well?
2. What didn't go well?
3. What will we improve?

Example:

code

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:

code

- 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:

code

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

User Stories

Format

code

As a [role]
I want [feature]
So that [benefit]

Examples

code

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

code

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

code

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:

code

❌ Hours or days
❌ Absolute measure

Fibonacci Scale:

code

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:

code

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:

code

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

code

Sprint 1: 15 points
Sprint 2: 18 points
Sprint 3: 16 points

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

Usage

code

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

code

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

code

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)

code

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

code

To Do | In Progress | In Review | Done
------|-------------|-----------|-----
Story | Story       | Story     | Story
Story | Task        | Task      | Story
Task  |             |           | Task

Example

code

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

code

- Jira
- Trello
- Azure DevOps
- Linear
- Asana

Common Metrics

Burndown Chart

code

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

code

Story Points

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

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

Cumulative Flow Diagram

code

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

code

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

SAFe (Scaled Agile Framework)

code

Team Level: Scrum teams
Program Level: Agile Release Train (ART)
Portfolio Level: Strategic themes

LeSS (Large-Scale Scrum)

code

One product backlog
One Product Owner
Multiple teams
Coordinated sprints

Best Practices

1. Keep Sprints Consistent

code

✓ Same duration (2 weeks recommended)
✓ Same day of week
✓ Predictable rhythm

2. Protect the Sprint

code

✓ No scope changes mid-sprint
✓ PO shields team from distractions
✓ Focus on sprint goal

3. Maintain Sustainable Pace

code

✓ Don't overcommit
✓ Leave buffer for unknowns
✓ Avoid burnout

4. Embrace Change

code

✓ Adapt based on feedback
✓ Continuously improve
✓ Inspect and adapt

5. Focus on Value

code

✓ Prioritize high-value features
✓ Deliver working software
✓ Get user feedback early

Common Pitfalls

❌ Scrum Theater

code

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

❌ Scope Creep

code

Adding work mid-sprint
- Breaks sprint commitment
- Reduces predictability
- Frustrates team

❌ Skipping Ceremonies

code

"We're too busy to do retrospectives"
- Misses improvement opportunities
- Repeats same mistakes

❌ Treating Scrum Master as Project Manager

code

SM assigns tasks and tracks hours
- Undermines self-organization
- Creates dependency

❌ Ignoring Definition of Done

code

"It's done except for tests"
- Accumulates technical debt
- Reduces quality

Transitioning to Scrum

Step 1: Training

code

- Scrum fundamentals for all
- Role-specific training
- Certified Scrum Master (CSM)

Step 2: Form Teams

code

- Cross-functional teams
- Assign roles (PO, SM, Dev)
- Co-locate if possible

Step 3: Create Backlog

code

- Gather requirements
- Write user stories
- Prioritize
- Estimate

Step 4: Run First Sprint

code

- Keep it simple
- Focus on learning
- Expect mistakes

Step 5: Inspect and Adapt

code

- Honest retrospectives
- Implement improvements
- Iterate on process

Tools and Resources

Project Management

code

- Jira (most popular)
- Azure DevOps
- Linear
- Trello
- Asana

Estimation

code

- Planning Poker (app or cards)
- Scrum Poker Online
- PlanITpoker

Retrospectives

code

- Retrium
- FunRetro
- Miro
- Metro Retro

Learning

code

- 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