What Is Scrum?
Scrum is the most widely adopted Agile framework, used by over 80% of Agile teams. Created by Ken Schwaber and Jeff Sutherland in the early 1990s, Scrum provides a lightweight framework for developing complex products through iterative and incremental delivery. It is intentionally incomplete — it defines the minimum structure needed and trusts teams to fill in the rest.
Scrum is built on three pillars of empirical process control: Transparency (everyone sees the same reality), Inspection (regularly examine progress and artifacts), and Adaptation (adjust the plan based on what is learned).
The Three Scrum Roles
Product Owner
The single person responsible for maximizing the value of the product and managing the product backlog.
- Owns the Product Backlog: Creates, orders, and communicates backlog items
- Defines Value: Articulates the product vision and ensures the team builds the right things
- Makes Decisions: Has final authority on what to build and in what order
- Accepts or Rejects Work: Determines if increments meet the Definition of Done
- Represents Stakeholders: Single voice for all business interests
Scrum Master
A servant-leader who helps the team follow Scrum practices and removes impediments to progress.
- Facilitates Events: Runs Sprint Planning, Daily Scrum, Review, and Retrospective
- Removes Impediments: Escalates and resolves blockers that slow the team
- Coaches the Team: Teaches Scrum practices and helps the team self-organize
- Protects the Team: Shields the team from external distractions and scope changes mid-sprint
- Drives Improvement: Facilitates retrospectives and follows up on action items
Development Team
A cross-functional, self-organizing group of professionals (typically 3-9 people) who do the work of delivering a potentially releasable increment each sprint.
- Self-Organizing: The team decides how to accomplish the work, not the Scrum Master or PO
- Cross-Functional: The team has all skills needed (frontend, backend, QA, design) to deliver
- No Sub-Teams: There are no titles or hierarchy within the dev team
- Collective Ownership: The whole team is accountable for the increment
The Five Scrum Events
| Event | Time-Box | Participants | Purpose | Output |
|---|---|---|---|---|
| Sprint | 1-4 weeks | Entire Scrum Team | Container for all other events | Done Increment |
| Sprint Planning | 8 hrs (4-wk sprint) | Entire Scrum Team | Define what and how for the sprint | Sprint Goal + Sprint Backlog |
| Daily Scrum | 15 minutes | Dev Team (others may observe) | Sync progress, identify blockers | Updated plan for the day |
| Sprint Review | 4 hrs (4-wk sprint) | Scrum Team + Stakeholders | Demo increment, get feedback | Updated Product Backlog |
| Sprint Retro | 3 hrs (4-wk sprint) | Scrum Team | Inspect and adapt the process | Improvement action items |
The Three Scrum Artifacts
Scrum artifacts represent work or value and are designed to maximize transparency:
- Product Backlog: An ordered list of everything that might be needed in the product. Owned by the Product Owner. Constantly refined and reprioritized.
- Sprint Backlog: The set of Product Backlog items selected for the sprint, plus a plan for delivering them. Owned by the Dev Team.
- Increment: The sum of all completed Product Backlog items during a sprint plus all previous increments. Must meet the Definition of Done.
Sprint Cycle Walkthrough
// Complete Sprint Data Model
interface Sprint {
id: string;
number: number;
goal: string;
startDate: Date;
endDate: Date;
duration: number; // in days
status: 'planning' | 'active' | 'review' | 'closed';
capacity: SprintCapacity;
backlog: SprintBacklogItem[];
ceremonies: SprintCeremony[];
metrics: SprintMetrics;
retrospective: Retrospective;
}
interface SprintCapacity {
totalPoints: number;
availableHours: number;
teamMembers: {
name: string;
role: string;
availableHours: number; // after PTO, meetings, etc.
focusFactor: number; // 0.6-0.8 typically
}[];
}
interface SprintBacklogItem {
id: string;
title: string;
type: 'story' | 'bug' | 'tech-debt' | 'spike';
storyPoints: number;
status: 'todo' | 'in-progress' | 'in-review' | 'done';
assignee: string;
acceptanceCriteria: string[];
tasks: {
description: string;
estimatedHours: number;
actualHours: number;
status: 'todo' | 'in-progress' | 'done';
}[];
}
interface SprintCeremony {
name: string;
date: Date;
duration: number; // minutes
attendees: string[];
notes: string;
}
interface SprintMetrics {
plannedPoints: number;
completedPoints: number;
velocity: number; // rolling average of last 3-5 sprints
burndownData: { day: number; remaining: number; ideal: number }[];
carryoverItems: number;
bugsFound: number;
bugsFixed: number;
}
interface Retrospective {
whatWentWell: string[];
whatDidNotGoWell: string[];
actionItems: {
description: string;
owner: string;
dueDate: Date;
status: 'open' | 'done';
}[];
}
// Example 2-week sprint
const sprint: Sprint = {
id: 'SPR-42',
number: 42,
goal: 'Complete user onboarding flow with email verification',
startDate: new Date('2024-03-11'),
endDate: new Date('2024-03-22'),
duration: 10,
status: 'active',
capacity: {
totalPoints: 34, // based on velocity
availableHours: 240,
teamMembers: [
{ name: 'Alice', role: 'Frontend', availableHours: 60, focusFactor: 0.7 },
{ name: 'Bob', role: 'Backend', availableHours: 64, focusFactor: 0.75 },
{ name: 'Carol', role: 'Full-Stack', availableHours: 56, focusFactor: 0.7 },
{ name: 'Dave', role: 'QA', availableHours: 60, focusFactor: 0.8 },
]
},
backlog: [
{
id: 'US-201',
title: 'User registration form with validation',
type: 'story',
storyPoints: 8,
status: 'done',
assignee: 'Alice',
acceptanceCriteria: [
'Form validates email format',
'Password meets security requirements',
'Error messages are user-friendly',
'Form is accessible (WCAG 2.1 AA)'
],
tasks: [
{ description: 'Build registration form UI', estimatedHours: 6, actualHours: 5, status: 'done' },
{ description: 'Add client-side validation', estimatedHours: 4, actualHours: 4, status: 'done' },
{ description: 'Connect to registration API', estimatedHours: 3, actualHours: 4, status: 'done' },
{ description: 'Write unit tests', estimatedHours: 3, actualHours: 3, status: 'done' },
]
},
{
id: 'US-202',
title: 'Email verification system',
type: 'story',
storyPoints: 13,
status: 'in-progress',
assignee: 'Bob',
acceptanceCriteria: [
'Verification email sent within 30 seconds of registration',
'Email contains unique token with 24-hour expiry',
'Clicking link verifies account and redirects to dashboard',
'Expired tokens show clear error with resend option'
],
tasks: [
{ description: 'Design email verification API', estimatedHours: 2, actualHours: 2, status: 'done' },
{ description: 'Implement token generation and storage', estimatedHours: 4, actualHours: 5, status: 'done' },
{ description: 'Build email sending service', estimatedHours: 6, actualHours: 4, status: 'in-progress' },
{ description: 'Create verification endpoint', estimatedHours: 3, actualHours: 0, status: 'todo' },
{ description: 'Write integration tests', estimatedHours: 4, actualHours: 0, status: 'todo' },
]
}
],
ceremonies: [
{ name: 'Sprint Planning', date: new Date('2024-03-11T09:00'), duration: 120, attendees: ['All'], notes: 'Selected 34 points, sprint goal agreed' },
{ name: 'Daily Scrum', date: new Date('2024-03-12T09:30'), duration: 15, attendees: ['Dev Team'], notes: 'No blockers' },
{ name: 'Sprint Review', date: new Date('2024-03-22T14:00'), duration: 60, attendees: ['All + Stakeholders'], notes: '' },
{ name: 'Sprint Retrospective', date: new Date('2024-03-22T15:30'), duration: 90, attendees: ['Scrum Team'], notes: '' },
],
metrics: {
plannedPoints: 34,
completedPoints: 21,
velocity: 32, // rolling average
burndownData: [
{ day: 1, remaining: 34, ideal: 34 },
{ day: 2, remaining: 34, ideal: 30.6 },
{ day: 3, remaining: 29, ideal: 27.2 },
{ day: 4, remaining: 26, ideal: 23.8 },
{ day: 5, remaining: 21, ideal: 20.4 },
],
carryoverItems: 0,
bugsFound: 3,
bugsFixed: 2
},
retrospective: {
whatWentWell: [
'Registration form shipped ahead of schedule',
'Pair programming on the email service was productive',
'No production incidents during the sprint'
],
whatDidNotGoWell: [
'Email service integration took longer than estimated',
'Missing test environment for email testing',
'Sprint goal at risk due to underestimation of US-202'
],
actionItems: [
{ description: 'Set up email sandbox environment (Mailtrap)', owner: 'Bob', dueDate: new Date('2024-03-25'), status: 'open' },
{ description: 'Add spike for complex stories in refinement', owner: 'Scrum Master', dueDate: new Date('2024-03-25'), status: 'open' }
]
}
};Definition of Done (DoD)
The Definition of Done is a shared checklist that every Product Backlog item must satisfy before it can be considered complete. It ensures quality and consistency across all increments.
Example Definition of Done
- ☑ Code is written and follows team coding standards
- ☑ All acceptance criteria are met
- ☑ Unit tests written and passing (>80% coverage on new code)
- ☑ Integration tests written and passing
- ☑ Code reviewed and approved by at least one peer
- ☑ No critical or high-severity bugs open
- ☑ Documentation updated (API docs, README if needed)
- ☑ Feature tested in staging environment
- ☑ Performance impact assessed (no regressions)
- ☑ Accessibility requirements met (WCAG 2.1 AA)
- ☑ Product Owner has accepted the story
Common Scrum Anti-Patterns
Watch Out For These
- Zombie Scrum: All ceremonies happen but no real collaboration or improvement occurs
- Sprint Scope Creep: New work is added mid-sprint without removing equivalent work
- Absent Product Owner: PO is not available for questions, leaving the team guessing
- Command-and-Control SM: Scrum Master tells the team what to do instead of facilitating
- No Retrospective Actions: Retros identify issues but nothing changes sprint over sprint
- Hardening Sprints: A "testing sprint" at the end suggests the DoD is not being followed