Scrum (software development)

Scrum is an iterative and incremental agile software development framework for managing product development. It defines "a flexible, holistic product development strategy where a development team works as a unit to reach a common goal", challenges assumptions of the "traditional, sequential approach" to product development, and enables teams to self-organize by encouraging physical co-location or close online collaboration of all team members, as well as daily face-to-face communication among all team members and disciplines in the project.

A key principle of Scrum is its recognition that during a project the customers can change their minds about what they want and need (often called "requirements churn"), and that unpredicted challenges cannot be easily addressed in a traditional predictive or planned manner. As such, Scrum adopts an empirical approach—accepting that the problem cannot be fully understood or defined, focusing instead on maximizing the team's ability to deliver quickly and respond to emerging requirements.

History

Scrum was first defined as "a flexible, holistic product development strategy where a development team works as a unit to reach a common goal" as opposed to a "traditional, sequential approach" in 1986 by Hirotaka Takeuchi and Ikujiro Nonaka in the "New New Product Development Game". Takeuchi and Nonaka later argued in "The Knowledge Creating Company" that it is a form of "organizational knowledge creation, [...] especially good at bringing about innovation continuously, incrementally and spirally".

The authors described a new approach to commercial product development that would increase speed and flexibility, based on case studies from manufacturing firms in the automotive, photocopier and printer industries. They called this the holistic or rugby approach, as the whole process is performed by one cross-functional team across multiple overlapping phases, where the team "tries to go the distance as a unit, passing the ball back and forth". (In rugby football, a scrum refers to a tight-packed formation of players with their heads down who attempt to gain possession of the ball. ).)

In the early 1990s, Ken Schwaber used what would become Scrum at his company, Advanced Development Methods, and Jeff Sutherland, with John Scumniotales and Jeff McKenna, developed a similar approach at Easel Corporation, and were the first to refer to it using the single word Scrum. In 1995, Sutherland and Schwaber jointly presented a paper describing the Scrum methodology at the Business Object Design and Implementation Workshop held as part of Object-Oriented Programming, Systems, Languages & Applications '95 (OOPSLA '95) in Austin, Texas, its first public presentation. Schwaber and Sutherland collaborated during the following years to merge the above writings, their experiences, and industry best practices into what is now known as Scrum.

In 2001, Schwaber worked with Mike Beedle to describe the method in the book Agile Software Development with Scrum. Its approach to planning and managing projects is to bring decision-making authority to the level of operation properties and certainties. Although the word is not an acronym, some companies implementing the process have been known to spell it with capital letters as SCRUM. This may be due to one of Ken Schwaber's early papers, which capitalized SCRUM in the title.

Later, Schwaber with others founded the Scrum Alliance and created the Certified Scrum Master programs and its derivatives. Ken left the Scrum Alliance in the fall of 2009, and founded Scrum.org to further improve the quality and effectiveness of Scrum.

Roles

There are three core roles and a range of ancillary roles. Core roles were previously referred to as pigs and ancillary roles as chickens (after the story The Chicken and the Pig).

The core roles are those committed to the project in the Scrum process—they are the ones producing the product (objective of the project). They represent the scrum team. Although other roles may be encountered in real projects, Scrum does not define any team roles other than those described below.

Product Owner

The Product Owner represents the stakeholders and is the voice of the customer. He or she is accountable for ensuring that the team delivers value to the business. The Product Owner writes (or has the team write) customer-centric items (typically user stories), ranks and prioritizes them, and adds them to the product backlog. Scrum teams should have one Product Owner, and while they may also be a member of the development team, this role should not be combined with that of the Scrum Master.

Role of Product Owner in defining and communicating product requirements

Communication is a main function of the product owner. The ability to convey priorities and empathize with team members and stakeholders are vital to steer the project in the right direction. Product owners bridge the communication gap between the team and their stakeholders. As Figure 1 shows, they serve as a proxy stakeholder to the development team and as a project team representative to the overall stakeholder community.

As the face of the team to the stakeholders, the following are some of the communication tasks of the product owner to the stakeholders:

• demonstrates the solution to key stakeholders who were not present in a normal iteration demo
• announces releases
• communicates team status
• organizes milestone reviews
• educates stakeholders in the development process
• negotiates priorities, scope, funding, and schedule
• ensures that the Product Backlog is visible, transparent, and clear

Empathy is a key attribute for a product owner to have – the ability to put one’s self in another’s shoes. A product owner will be conversing with different stakeholders in the project – different people, with a variety of backgrounds, job roles, and objectives. A product owner needs to be able to see from these different points of view. To be effective, it would also be wise for a product owner to know the level of detail the audience needs from him or her. The development team would need thorough feedback and specifications so they build a product up to expectation, while an executive sponsor may just need summaries of progress. Providing more information than necessary may lose stakeholder interest and waste time. There is also significant evidence that face-to-face communication around a shared sketching environment is the most effective way to communicate information instead of documentation. A direct means of communication is then most preferred by seasoned agile product owners.

A product owner’s ability to communicate effectively is also enhanced by being skilled in techniques that identify stakeholder needs, negotiate priorities between stakeholder interests, and collaborate with developers to ensure effective implementation of requirements.

Development Team

The Development Team is responsible for delivering potentially shippable increments (PSIs) of product at the end of each Sprint (the Sprint Goal). A Team is made up of 3–9 individuals with cross-functional skills who do the actual work (analyse, design, develop, test, technical communication, document, etc.). The Development Team in Scrum is self-organizing, even though there may be some level of interface with project management offices (PMOs).

Scrum Master

Scrum is facilitated by a Scrum Master, who is accountable for removing impediments to the ability of the team to deliver the product goals and deliverables. The Scrum Master is not a traditional team lead or project manager, but acts as a buffer between the team and any distracting influences. The Scrum Master ensures that the Scrum process is used as intended. The Scrum Master is the enforcer of the rules of Scrum, often chairs key meetings, and challenges the team to improve. The role has also been referred to as a servant-leader to reinforce these dual perspectives.

The Scrum Master differs from a project manager in that the latter may have people management responsibilities unrelated to the role of Scrum Master. The Scrum Master role excludes any such additional people responsibilities. In fact, there is no role of project manager in Scrum, and practicing Scrum with a project manager included may cause difficulties.

Events

Sprint

The Scrum process

A sprint (or iteration) is the basic unit of development in Scrum. The sprint is a "timeboxed" effort; that is, it is restricted to a specific duration. The duration is fixed in advance for each sprint and is normally between one week and one month, although two weeks is typical.

Each sprint is started by a planning meeting. The aim is to define a sprint backlog where the tasks for the sprint are identified and an estimated commitment for the sprint goal is made. Each sprint is ended by a sprint review-and-retrospective meeting, where the progress is reviewed and shown to stakeholders and improving lessons for the next sprints are identified.

Scrum emphasizes working product at the end of the Sprint that is really "done"; in the case of software, this means a system that is integrated, fully tested, end-user documented, and potentially shippable.

Meetings

Sprint planning meeting

At the beginning of the sprint cycle (every 7–30 days), a "Sprint planning meeting" is held:

• Select what work is to be done
• Prepare the Sprint Backlog that details the time it will take to do that work, with the entire team
• Identify and communicate how much of the work is likely to be done during the current sprint
• Eight-hour time limit for a 30-days sprint (i.e. two hours per week duration)
  • (First four hours) Entire team (Dev.Team, Scrum Master, Product Owner): dialogue for prioritizing the Product Backlog
  • (Second four hours) Development Team: hashing out a plan for the Sprint, resulting in the Sprint Backlog

Daily scrum meeting

A daily scrum meeting in the computing room. This centralized location helps the team start on time.

Each day during the sprint, a project team communication meeting occurs. This is called the daily scrum (meeting) (or "stand-up meeting") and has specific guidelines:

• All members of the development team come prepared with the updates for the meeting.
• The meeting starts precisely on time even if some development team members are missing.
• The meeting should happen at the same location and same time every day.
• The meeting length is set (timeboxed) to 15 minutes.
• All are welcome, but normally only the core roles speak.

During the meeting, each team member answers three questions:

• What did I do yesterday that helped the Development Team meet the Sprint Goal?
• What will I do today to help the Development Team meet the Sprint Goal?
• Do I see any impediment that prevents me or the Development Team from meeting the Sprint Goal?

Any impediment/stumbling block identified in this meeting is documented by the Scrum Master and worked towards resolution outside of this meeting. No detailed discussions shall happen in this meeting.

End meetings (Sprint Review and Sprint Retrospective)

At the end of a sprint cycle, two meetings are held: the "Sprint Review Meeting" and the "Sprint Retrospective".

At the Sprint Review Meeting:

• Review the work that was completed and the planned work that was not completed
• Present the completed work to the stakeholders (a.k.a. "the demo")
• Incomplete work cannot be demonstrated
• Four-hour time limit

At the Sprint Retrospective:

• All team members reflect on the past sprint
• Make continuous process improvements
• Two main questions are asked in the sprint retrospective: What went well during the sprint? What could be improved in the next sprint?
• Three-hour time limit
• This meeting is facilitated by the Scrum Master

Extensions

Backlog refinement (grooming)

Backlog refinement is the ongoing process of reviewing product backlog items and checking that they are appropriately prioritised and prepared in a way that makes them clear and executable for teams once they enter sprints via the sprint planning activity. Product backlog items may be broken into multiple smaller ones, acceptance criteria may be clarified, or new preparatory work such as clarification on client needs or technical spikes may be identified.

Backlog refinement is not a core Scrum practice but has been adopted as a way of managing the quality of backlog items entering a sprint.

Scrum of scrums

The Scrum of Scrums (meeting) is a technique to scale Scrum up to large development groups (over a dozen people), which allows clusters of teams to discuss their work, focusing especially on areas of overlap and integration. Each daily scrum within a sub-team ends by designating one member as an "ambassador" to participate in a daily meeting with ambassadors from other teams, called the Scrum of Scrums. Depending on the context, ambassadors may be technical contributors, or each team’s Scrum Master.

The agenda will be like a Daily Scrum, with the following four questions:

• What has your team done since we last met?
• What will your team do before we meet again?
• Is anything slowing your team down or getting in their way?
• Are you about to put something in another team's way?

Resolution of impediments is expected to focus on the challenges of coordination between the teams, and may entail agreeing to interfaces between teams, negotiating responsibility boundaries, etc. The Scrum of Scrums will track these working items via a backlog of its own, where each item contributes to improving between-team coordination.

As Jeff Sutherland commented,

Since I originally defined the Scrum of Scrums (Ken Schwaber was at IDX working with me), I can definitively say the Scrum of Scrums is not a "meta Scrum". The Scrum of Scrums as I have used it is responsible for delivering the working software of all teams to the Definition of Done at the end of the Sprint, or for releases during the sprint. PatientKeeper delivered to production four times per Sprint. Ancestry.com delivers to production 220 times per two week sprint. Hubspot delivers live software 100-300 times a day. The Scrum of Scrums Master is held accountable for making this work. So the Scrum of Scrums is an operational delivery mechanism.

Artifacts

Product backlog

The product backlog is an ordered list of requirements that is maintained for a product. It consists of features, bug fixes, non-functional requirements, etc.—whatever needs to be done in order to successfully deliver a viable product. The product backlog items (PBIs) are ordered by the Product Owner based on considerations like risk, business value, dependencies, date needed, etc.

Items added to a backlog are commonly written in story format. The product backlog is what will be delivered, ordered into the sequence in which it should be delivered. It is open and editable by anyone, but the Product Owner is ultimately responsible for ordering the items on the backlog for the Development Team to choose.

The product backlog contains the Product Owner's assessment of business value and the Development Team's assessment of development effort, which are often, but not always, stated in story points using a rounded Fibonacci sequence. These estimates help the Product Owner to gauge the timeline and may influence ordering of backlog items; for example, if the "add spellcheck" and "add table support" features have the same business value, the Product Owner may schedule earlier delivery of the one with the lower development effort (because the ROI (Return on Investment) is higher) or the one with higher development effort (because it is more complex or riskier, and they want to retire that risk earlier).

The product backlog and the business value of each backlog item is the responsibility of the Product Owner. The size (i.e. estimated complexity or effort) of each backlog item is, however, determined by the Development Team, who contributes by sizing items, either in story points or in estimated hours.

There is a common misunderstanding that only user stories are allowed in a Product Backlog. By contrast, Scrum is neutral on requirement techniques. As the Scrum Primer states,

Product Backlog items are articulated in any way that is clear and sustainable. Contrary to popular misunderstanding, the Product Backlog does not contain "user stories"; it simply contains items. Those items can be expressed as user stories, use cases, or any other requirements approach that the group finds useful. But whatever the approach, most items should focus on delivering value to customers.

Scrum advocates that the role of Product Owner be assigned. The Product Owner is responsible for maximizing the value of the product and the work of the Development Team. The Product Owner gathers input, takes feedback and is lobbied by many people, but it will ultimately make the call on what gets built. They are also solely responsible for the management of the backlog.

The product backlog is used to:

• capture requests for modifying a product. This can include adding new features, replacing old features, removing features and fixing issues
• ensure the delivery team is given work which maximizes the business benefit to the owner of the product

Typically, the product owner and the SCRUM team come together and write down everything that needs to be prioritized and this becomes content for the first sprint, which is a block of time meant for focused work on selected items that can be accommodated within a timeframe. The SCRUM product backlog is permitted to evolve as new information surfaces about the product and its customers, and so new work are tackled for next sprints.

The following items typically comprise a scrum backlog: features, bugs, technical work, and knowledge acquisition. In the web development sphere, there is confusion as to the difference between a feature and a bug, technically a feature is “wanted”, while a bug is a feature that is “unintended” or “unwanted” (but may not be necessarily a defective thing). An example of technical work would be, “run virus check on all developers workstations”. An example of knowledge acquisition could be a scrum backlog item about researching Wordpress plugin libraries and making a selection.

Managing the product backlog between product owner and scrum team

A backlog, in its simplest form, is merely a list of items to be worked on. Having well established rules about how work is added, removed and ordered helps the whole team make better decisions about how to change the product.

The product owner prioritizes which of the product backlog are most needed. The team then chooses which items can be completed in the coming sprint. On the SCRUM board, the team moves items from the product backlog to the sprint backlog, which is the list of items they will build. Conceptually, it is ideal for the team to only select what they think they can accomplish from the top of the list, but it is not unusual to see in practice that teams are able to take lower priority items from the list along with the top ones selected. This normally happens because there is time left within the sprint to accommodate more work. Items at the top of the backlog, the items that are going to be worked on first, should be broken down into stories that are suitable for the delivery team to work on. The further down the backlog goes, the less refined the items should be. As Schwaber and Beedle put it “The lower the priority, the less detail, until you can barely make out the backlog item.”

As the team works through the backlog, it needs to be assumed that “changes in the world can happen”—the team can learn about new market opportunities to take advantage of, competitor threats that arise, and feedback from customers that can change the way the product was meant to work. All of these new ideas tend to trigger the team to adapt the backlog to incorporate new knowledge. This is part of the fundamental mindset of an agile team. The world changes, the backlog is never finished.

Sprint backlog

A Scrum task board

The sprint backlog is the list of work the Development Team must address during the next sprint. The list is derived by selecting product backlog items from the top of the product backlog until the Development Team feels it has enough work to fill the sprint. This is done by the Development Team asking "Can we also do this?" and adding product backlog items to the sprint backlog. The Development Team should keep in mind its past performance assessing its capacity for the new sprint, and use this as a guide line of how much "effort" they can complete.

The product backlog items are broken down into tasks by the Development Team. Tasks on the sprint backlog are never assigned; rather, tasks are signed up for by the team members as needed according to the set priority and the Development Team member skills. This promotes self-organization of the Development Team, and developer buy-in.

The sprint backlog is the property of the Development Team, and all included estimates are provided by the Development Team. Often an accompanying task board is used to see and change the state of the tasks of the current sprint, like "to do", "in progress" and "done".

Once a Sprint Backlog is committed, no additional functionality can be added to the Sprint backlog except by the team. Once a Sprint has been delivered, the Product Backlog is analyzed and reprioritized if necessary, and the next set of functionality is selected for the next Sprint.

Product Increment

The increment (or potentially shippable increment, PSI) is the sum of all the Product Backlog items completed during a sprint and all previous sprints. At the end of a sprint, the Increment must be done according to the Scrum Team's criteria called Definition of Done (DoD). The increment must be in a usable condition regardless of whether the Product Owner decides to actually release it.

Sprint Burndown chart

A sample burn down chart for a completed iteration, showing remaining effort and tasks for each of the 21 work days of the 1-month iteration

Main article: Burn down chart

The sprint burndown chart is a public displayed chart showing remaining work in the sprint backlog. Updated every day, it gives a simple view of the sprint progress. It also provides quick visualizations for reference. During the sprint planning meeting the ideal burndown chart is plotted. Then, during the sprint, each member picks up tasks from the sprint backlog and works on them. At the end of the day, they update the remaining hours for tasks to be completed. In such way the actual burndown chart is updated day by day.

It should not be confused with an earned value chart.

Release burndown chart

The release burndown chart is the way for the team to track progress and provide visibility. The release burndown chart is updated at the end of each sprint by the ScrumMaster. The horizontal axis of the sprint burndown chart shows the sprints; the vertical axis shows the amount of work remaining at the start of each sprint. The release burndown chart makes it easy to drill down into a sprint and understand what is the remaining work, what work has been added, what work has been done, what work will have to be done. You can see what the team has completed as well as how scope changed.

Terminology

The following terms are often used in a Scrum process.

Scrum Team

Product Owner, Scrum Master and Development Team

Product Owner

The person responsible for maintaining the Product Backlog by representing the interests of the stakeholders, and ensuring the value of the work the Development Team does.

Scrum Master

The person responsible for the Scrum process, making sure it is used correctly and maximizing its benefits.

Development Team

A cross-functional group of people responsible for delivering potentially shippable increments of Product at the end of every Sprint.

Sprint burn down chart

Daily progress for a Sprint over the sprint's length.

Release burn down chart

Sprint level progress of completed product backlog items in the Product Backlog.

Product backlog (PBL)

A prioritized list of high-level requirements.

Sprint backlog (SBL)

A prioritized list of tasks to be completed during the sprint.

Sprint

A time period (typically 1–4 weeks) in which development occurs on a set of backlog items that the team has committed to. Also commonly referred to as a Time-box or iteration.

Spike

A time boxed period used to research a concept and/or create a simple prototype. Spikes can either be planned to take place in between sprints or, for larger teams, a spike might be accepted as one of many sprint delivery objectives. Spikes are often introduced before the delivery of large or complex product backlog items in order to secure budget, expand knowledge, and/or produce a proof of concept. The duration and objective(s) of a spike will be agreed between the Product Owner and Delivery Team before the start. Unlike sprint commitments, spikes may or may not deliver tangible, shippable, valuable functionality. For example, the objective of a spike might be to successfully reach a decision on a course of action. The spike is over when the time is up, not necessarily when the objective has been delivered.

Tracer Bullet

The tracer bullet is a spike with the current architecture, current technology set, current set of best practices which results in production quality code. It might just be a very narrow implementation of the functionality but is not throw away code. It is of production quality and the rest of the iterations can build on this code. The name has military origins as ammunition that makes the path of the bullet visible, allowing for corrections. Often these implementations are a 'quick shot' through all layers of an application, such as connecting a single form's input field to the back-end, to prove the layers will connect as expected.

Tasks

Work items added to the sprint backlog at the beginning of a sprint and broken down into hours. Each task should not exceed 12 hours (or two days), but it's common for teams to insist that a task take no more than a day to finish.

Definition of Done (DoD)

The exit-criteria to determine whether a product backlog item is complete. In many cases the DoD requires that all regression tests should be successful. The definition of "done" may vary from one Scrum team to another, but must be consistent within one team.

Velocity

The total effort a team is capable of in a sprint. The number is derived by evaluating the work (typically in user story points) completed from the last sprint's backlog items. The collection of historical velocity data is a guideline for assisting the team in understanding how much work they can do in a future sprint.

Impediment

Anything that prevents a team member from performing work as efficiently as possible.

Sashimi

A term used to describe one or more user stories, indicating that they are thin slices of a product feature or capability.

Abnormal Termination

The Product Owner can cancel a Sprint if necessary. The Product Owner may do so with input from the team, Scrum Master or management. For instance, management may wish to cancel a sprint if external circumstances negate the value of the sprint goal. If a sprint is abnormally terminated, the next step is to conduct a new Sprint planning meeting, where the reason for the termination is reviewed.

ScrumBut

A ScrumBut (or Scrum But) is an exception to the "pure" Scrum methodology, where a team has changed the methodology to adapt it to their own needs.

ScrumBag

A ScrumBag (or Scrum Bag) refers to the person, group, or any other blockers that could be a factor for Impediment.

Scrum-ban

Main article: Scrum ban

Scrum-ban is a software production model based on Scrum and Kanban. Scrum-ban is especially suited for maintenance projects or (system) projects with frequent and unexpected work items or programming errors. In such cases the time-limited sprints of the Scrum model are of no appreciable use, but Scrum's daily meetings and other practices can be applied, depending on the team and the situation at hand. Visualization of the work stages and limitations for simultaneous unfinished work and defects are familiar from the Kanban model. Using these methods, the team's workflow is directed in a way that allows for minimum completion time for each work item or programming error, and on the other hand ensures each team member is constantly employed.

To illustrate each stage of work, teams working in the same space often use post-it notes or a large whiteboard. In the case of decentralized teams, stage-illustration software such as Assembla, TargetProcess, Eylean Board, JIRA or Agilo for Scrum.

In their simplest, the tasks are categorized into the work stages:

• Unstarted
• Ongoing
• Completed

If desired, though, the teams can add more stages of work (such as "defined", "designed", "tested" or "delivered"). These additional phases can be of assistance if a certain part of the work becomes a bottleneck and the limiting values of the unfinished work cannot be raised. A more specific task division also makes it possible for employees to specialize in a certain phase of work.

There are no set limiting values for unfinished work. Instead, each team has to define them individually by trial and error; a value too small results in workers standing idle for lack of work, whereas values too high tend to accumulate large amounts of unfinished work, which in turn hinders completion times. A rule of thumb worth bearing in mind is that no team member should have more than two simultaneous selected tasks, and that on the other hand not all team members should have two tasks simultaneously.

The major differences between Scrum and Kanban are derived from the fact that, in Scrum, work is divided into sprints that last a certain amount of time, whereas in Kanban the workflow is continuous. This is visible in work stage tables, which in Scrum are emptied after each sprint. In Kanban all tasks are marked on the same table. Scrum focuses on teams with multifaceted know-how, whereas Kanban makes specialized, functional teams possible.

Since Scrum-ban is such a new development model, there is not much reference material. Kanban, on the other hand, has been applied by Microsoft and Corbis.

Tooling

Like other agile methods, Scrum can be implemented through a wide range of tools.

Many companies use universal tools, such as spreadsheets to build and maintain artifacts such as the sprint backlog. There are also open-source and proprietary packages dedicated to management of products under the Scrum process. Other organizations implement Scrum without the use of any software tools, and maintain their artifacts in hard-copy forms such as paper, whiteboards, and sticky notes.

Limitations

Hybridization of Scrum is common as Scrum does not cover the whole product development lifecycle; therefore, organizations find the need to add in additional processes to create a more comprehensive implementation. For example, at the start of the project, organizations commonly add process guidance on requirements gathering and prioritization, initial high-level design, and budget and schedule forecasting. However, the Scrum framework does not explicitly allow for extension points of such a kind; consequently, achieving a more comprehensive software life cycle requires extending the framework rather than instantiating it.

See also

• Disciplined Agile Delivery
• Extreme programming
• Kanban
• Lean software development
• Project management
• Unified Process

Further reading

• Jeff Sutherland; Ken Schwaber (2013). "Scrum Guides". ScrumGuides.org. Retrieved October 2013. {{cite web}}: Check date values in: |accessdate= (help)
• N.S. Janoff; L. Rising (2000). "The Scrum Software Development Process for Small Teams" (PDF). Retrieved March 15, 2007.
• Deemer, Pete; Benefield, Gabrielle; Larman, Craig; Vodde, Bas (2009). "The Scrum Primer". Retrieved June 1, 2009.
• Kniberg, Henrik. "Scrum and XP from the Trenches". Retrieved August 9, 2010.
• Münch, Jürgen; Armbrust, Ove; Soto, Martín; Kowalczyk, Martin (2012). "Software Process Definition and Management". Retrieved July 16, 2012.
• Ambler, Scott (2013). "Going Beyond Scrum: Disciplined Agile Delivery" (PDF). Retrieved February 4, 2014.

External links

• Agile Alliance's Scrum library
• A Scrum Process Description by the Eclipse Process Framework (EPF) Project
• BPMN process diagram of Scrum