Scrum

An Agile framework for managing and completing complex projects.

Practices Employed

• Approvals: Scrum requires approval during sprint reviews and at the end of each sprint. Referred to as:
  • Sprint Review
• Automated Testing: Unit testing is part of the Definition of Done in Scrum. Referred to as:
  • Unit Testing
• Automation: Automation of tests and integration (CI/CD) is common in Scrum practices.
• Change Management: Changes are managed through the product backlog and sprint planning.
• Coding: Coding is a core activity in Scrum as it is in any software development framework.
• Configuration Management: Configuration management helps maintain the consistency of the product's performance.
• Debugging: Debugging is an essential part of the development process in Scrum.
• Demo: Scrum includes sprint reviews which act as demos for stakeholders.
• Documentation: Documentation is produced, but Scrum values working software over comprehensive documentation.
• Estimating: Estimation is performed during sprint planning using techniques like story points. Referred to as:
  • Planning Poker
  • Sprint Planning
• Integration Testing: Integration testing is part of the Definition of Done in Scrum.
• Issue Management: Issues are logged and tracked through tools like JIRA to ensure they are resolved promptly. Referred to as:
  • Sprint Backlog
• Measurement: Scrum uses various metrics like burndown charts to measure progress. Referred to as:
  • Burndown Chart
  • Definition of Done
• Meeting: Scrum uses various face-to-face meetings. Referred to as:
  • Daily Stand-ups
  • Retrospectives
• Monitoring: Monitoring progress through daily stand-ups and sprint reviews is integral to Scrum. Referred to as:
  • Daily Stand-ups
• Prioritising: Scrum prioritizes work during sprint planning and focuses on delivering a potentially shippable product increment. Referred to as:
  • Sprint Planning
  • Sprint Goal
  • Product Backlog Refinement
• Refactoring: Refactoring is encouraged to maintain code quality within Scrum.
• Regression Testing: Regression testing is part of the Definition of Done to ensure changes don't break existing functionality.
• Release: Scrum focuses on frequent releases, with potentially shippable increments delivered at the end of each sprint.
• Requirements Capture: Capturing requirements is done through user stories and the product backlog in Scrum. Referred to as:
  • User Stories
• Retrospectives: Retrospectives are a key part of Scrum for continuous improvement. Referred to as:
  • Sprint Retrospective
• Review: Scrum includes regular reviews in the form of sprint reviews and retrospectives.
• Stakeholder Management: Stakeholder engagement is critical in Scrum, especially through the role of the Product Owner.
• Version Control: Version control is a best practice in software development, including in Scrum.

Addresses / Mitigates

Risk	Practices
Agency Risk	Estimating: Helps in planning and managing staff usage effectively. Monitoring: Monitoring the behaviour of agents, whether people or processes, helps identify when behaviour becomes counter-productive. Review: Reviewing work or activity can ensure good behaviour. Stakeholder Management: Aligns the goals and expectations of various stakeholders, reducing conflicts.
Communication Risk	Approvals: Provides formal communication of acceptance and readiness. Demo: Facilitates clear communication of the product's features and benefits to stakeholders. Documentation: Provides clear guidelines and information, reducing misunderstandings. Issue Management: Facilitates communication about issues and their status among team members. Meeting: Facilitates clear and direct communication among team members. Refactoring: Well-factored code should be easier to understand. Requirements Capture: Helps in explaining exactly what should be built. Review: Maintains alignment with design principles and goals. Stakeholder Management: Facilitates clear and consistent communication between stakeholders.
Complexity Risk	Automated Testing: Aids in refactoring by ensuring that functionality survives the change. Configuration Management: Reduces complexity by managing system changes in a controlled and documented manner. Refactoring: Refactoring is aimed at making code more orthogonal, less duplicative and clearer to understand Review: Identifies unnecessary complexity and communicates necessary complexity to the rest of the team.
Coordination Risk	Change Management: Specifically addresses coordinating change in a structured way. Meeting: Ensures everyone is on the same page regarding project goals and progress. Requirements Capture: Reduces coordination risks around deciding what should be built. Retrospectives: Identifies and addresses historic coordination issues through regular reviews. Stakeholder Management: Allows stakeholders to coordinate on their demands. Version Control: Facilitates collaboration by allowing multiple developers to work on the codebase simultaneously.
Deadline Risk	Estimating: Provides realistic timelines helps hit important deadlines. Prioritising: In order to hit a deadline, you can de-prioritise less important work.
Feature Fit Risk	Coding: Build or improve some features which our clients will find useful. Demo: Showcases the product to ensure it meets client expectations and needs. Measurement: Helps in understanding the use of the system. Release: Putting new features in the hands of users can make your product fit their needs better. Requirements Capture: Ensures that features align with client needs and expectations. Retrospectives: Captures feedback and adjusts features to meet evolving needs.
Funding Risk	Estimating: Accurate estimation helps in securing and managing funding. Prioritising: Allocates resources efficiently to high-impact areas. Release: Delivering features might mean you get paid for the software you write.
Implementation Risk	Approvals: Ensures that work meets the required standards and specifications before progressing. Automated Testing: Ensures that individual components work correctly and detects regressions early in the development cycle. Change Management: Avoid bugs from creeping into the system. Configuration Management: Establishes and maintains consistency in the software product's performance and attributes. Debugging: Identifies and fixes defects in the software. Demo: Demonstrations often highlight issues in implementations Integration Testing: Validates that the implementation meets requirements and detects regressions early in the integration phase. Issue Management: Tracks and manages defects and issues, ensuring they are resolved. Measurement: Identifies areas of improvement in the implementation process. Refactoring: Enhances code quality and maintainability. Regression Testing: Detects and prevents regressions in the software. Review: Ensures quality and correctness of work products. Version Control: Maintains a history of changes, allowing rollback to previous versions if needed.
Internal Model Risk	Demo: Prototypes are a way of learning about a particular solution to a problem. Documentation: Detailed documentation helps manage and understand complex systems. Retrospectives: Looking at what went wrong before leads to improving the internal model of risk for the future. Review: Reviews and audits can uncover unseen problems in a system. Stakeholder Management: Talking to stakeholders helps to share and socialise Internal Models.
Market Risk	Prioritising: Ensures that the most valuable features and opportunities are addressed first. Release: Delivering features means you get market feedback.
Operational Risk	Automation: Introduces more consistency in process operations and removes opportunity for human error Change Management: Ensures changes are implemented smoothly and systematically. Configuration Management: Ensures that changes are systematically evaluated and implemented to minimize disruptions. Debugging: Ensures that the software operates correctly and efficiently. Issue Management: Provides a systematic approach to managing and addressing operational issues. Measurement: Provides data to inform decision-making and improve operational efficiency. Monitoring: Ensures continuous observation to maintain operational stability.
Process Risk	Coding: Problems and edge cases with software processes can be fixed by adding code. Monitoring: Monitoring a process can ensure that when it misbehaves the issues are quickly caught. Retrospectives: Continuously improves processes and practices.
Reliability Risk	Debugging: Removing bugs improves the reliability and stability of the software. Integration Testing: Ensures that integrated components work together as expected. Monitoring: Identifies and addresses potential issues before they impact system reliability. Regression Testing: Regression testing helps prevent reliability breaks caused by software change. Review: Reviews and audits can be performed to investigate the causes of unreliability in a system.
Reputational Risk	Issue Management: Tracking and fixing bugs improves software reputation.
Schedule Risk	Automation: Automating laborious tasks clears the schedule for higher-value work. Prioritising: Helps in focusing on high-priority tasks.
Security Risk	Issue Management: Track and Prioritise Security Issues and Incidents. Monitoring: Monitors for security breaches and anomalies.

Attendant Risks

Attendant Risk	Practices
Agency Risk	Automation: Automated processes have their own agency and might not work as desired. Estimating: Can put unnecessary pressure on staff to hit deadlines.
Communication Risk	Automation: The quality and performance characteristics may be obscured by automation. Stakeholder Management: Misaligned communication strategies can lead to misunderstandings and conflicts. Version Control: Poor version management can be chaotic and leave lots of work in progress.
Complexity Risk	Automated Testing: Managing a large suite of unit tests can add to the complexity. Automation: Introducing automation adds to the complexity of a project Coding: Writing new code adds complexity to a project. Documentation: Documentation is also a source of complexity on a project and can slow down change. Issue Management: Managing an excessive number of logged issues can add complexity. Measurement: Collecting and analyzing data can add to the complexity of the project. Monitoring: Implementing comprehensive monitoring solutions can add complexity. Regression Testing: Managing extensive regression tests can add complexity.
Coordination Risk	Approvals: Requires coordination among stakeholders to provide timely sign-off. Meeting: Meetings usually happen at a particular time so involve coordinating schedules. Review: Synchronous reviews require effective coordination among team members.
Deadline Risk	Estimating: Can create dependencies on estimated timelines and resources. Prioritising: Establishing an order of events often places deadlines on the earlier events completing or the later events starting.
Feature Fit Risk	Automation: The automated process might not capture the variability of requirements of the original approach
Funding Risk	Measurement: Implementing measurement systems can be expensive. Monitoring: High-quality monitoring tools and systems can be costly.
Implementation Risk	Coding: Changes in code can introduce new bugs and regressions. Refactoring: Done carelessly, refactoring can introduce new issues into the codebase
Internal Model Risk	Automated Testing: Unit Testing and code coverage can give false assurances about how a system will work in the real world. Automation: Automation of reporting and statuses can lead to false confidence about a system's health. Measurement: Focusing on the wrong measures can blind you to what's important.
Legal Risk	Release: Publishing or releasing code may involve licensing, Intellectual Property, Liability or other legal compliance."
Market Risk	Prioritising: Prioritising a single client or narrowing scope reduces diversification, increasing exposure to changes in the market.
Operational Risk	Automation: Automated processes may be less observable than manual ones. Release: Releasing software means that the software has to be supported in production.
Process Risk	Approvals: Adding approvals to a process increases the number of stakeholders involved and can impact process performance. Automation: Automation introduces a process, which therefore means a new source of Process Risk. Change Management: Change control is a process, and therefore is a source of process risk. Issue Management: The issue lifecycle from creation to resolution is a process, therefore a source of process risk. Meeting: Decisions may be delayed if consensus is not reached during the meeting. Release: Complex release procedures are a source of process risk.
Reliability Risk	Automated Testing: Creates dependencies on testing frameworks and tools. Configuration Management: Carefully managing software configuration ensures that the reliability of dependencies is also managed. Integration Testing: Adds dependencies on test environments and their availability. Measurement: Creates dependencies on measurement tools and their accuracy. Monitoring: Creates dependency on monitoring tools and their accuracy. Prioritising: Prioritization can create dependencies on specific tasks or features. Regression Testing: Requires a stable testing environment, creating dependencies. Release: Releases can introduce discontinuities in software service if not managed well.
Reputational Risk	Release: Poor release management can destroy reputation and good-will.
Schedule Risk	Approvals: Waiting for approvals can introduce delays in the project timeline. Automated Testing: Writing and maintaining unit tests can be time-consuming. Change Management: Managing changes systematically can introduce delays. Debugging: Debugging can be time-consuming, affecting project timelines. Demo: Demos can introduce delays if not planned and executed properly. Documentation: Creating and maintaining documentation can be time-consuming. Estimating: Inaccurate estimates can lead to schedule overruns. Integration Testing: Can be time-consuming, leading to delays in the project timeline. Issue Management: Managing and resolving logged issues can impact project timelines. Meeting: Can consume a significant amount of time if not managed effectively. Refactoring: Refactoring can be time-consuming and delay project timelines. Regression Testing: Can be time-consuming and introduce delays. Release: Delays in the release process can impact overall project time-lines. Requirements Capture: Thorough requirements capture can be time-consuming. Retrospectives: Requires coordination and can disrupt regular workflows. Review: Reviews can introduce delays in the project timeline.
Security Risk	Automation: Automation can introduce security issues if automated processes are given elevated privileges.

Description

"Scrum prescribes for teams to break work into goals to be completed within time-boxed iterations, called sprints. Each sprint is no longer than one month and commonly lasts two weeks. The scrum team assesses progress in time-boxed, stand-up meetings of up to 15 minutes, called daily scrums. At the end of the sprint, the team holds two further meetings: one sprint review to demonstrate the work for stakeholders and solicit feedback, and one internal sprint retrospective. A person in charge of a scrum team is typically called a scrum master." - Scrum (software development), Wikipedia

Scrum is an Agile framework that focuses on iterative progress through small, cross-functional teams. Key practices in Scrum include sprint planning, daily stand-ups, sprint reviews, and retrospectives. Scrum emphasizes collaboration, flexibility, and continuous improvement, making it a popular choice for managing complex projects.

See Also

Large-Scale Scrum (LeSS)

A framework for scaling agile development to multiple teams.