Agile Practice: SCRUM

What is SCRUM?

Scrum is a lightweight agile practice that doesn’t take too much time away from production, uses both the iterative and incremental system process models, and enhances predictability and mitigates risks.

Pillars of SCRUM

  • Transparency
    • It means that everyone can see every part of the project. This means that both the Scrum team and the client is familiar of the development updates.
    • Here, the team is agreeing on using common terminology to use through development.
  • Inspection
    • Scrum encourages frequent inspection of work products and progress to detect undesirable deviations from expectations
  • Adaptation
    • When the team has found themselves deviating from the software requirements, they should be able to easily adapt and adjust. Also, called Scrum events, these techniques to help with this are:
      • Sprint Planning
      • Daily Scrum
      • Sprint Review
      • Sprint Retrospective

All these events are time-boxed, meaning the Scrum team needs to specify a maximum time for the duration of each events and adhere to that. Let’s look at each one.

Photo from under CC BY SA 4.0

Sprint is a development phase of a specific amount of time, in which a working prototype is delivered to the client. Here, the sprint lasts one month or less, typically 1 or 2 weeks. After each sprint, a working prototype is delivered to the client. Each spring consists of the four scrum events, which are:

Spring Planning – occurs at the beginning of the current Sprint to determine what will be completed in Sprint.

Daily Scrum – this is a daily meeting that occurs at the beginning of each day so that the team can talk about the tasks they will need to accomplish for the day.

Sprint Review – this occurs at the end of the Sprint. This is also where the working prototype is delivered. It reviews what has been accomplished, what has been tagged as “DONE” and what needs additional increment for the next sprint.

Sprint Retroactive – this is where the suggestions that will change the Sprint goal will go to the Backlog, to start the next Sprint as the product owner decides.

How is a feature considered ”DONE“? A feature is considered done when it is coded, tested and documented. During a sprint, a requirements change is not allowed if it is outside the sprint goal.


A Scrum team consists of the product owner, development team and the scrum master.

Product Owner – the one in charge of making decisions about the product and the product backlog. He/She can represent a committe but can be the only one who can implement the changes to the product.

Development Team – the teams in Scrum are self-organizing, which means that they are in charge of taking their backlog of features and turn them into increments of working software. The team are also cross-functional where each member can be specialists from different areas but are able to do tasks other members can do. Lastly, the development team has no subteams, and can only consist of about 3-8 developers.

Scrum Master – the scrum master is the coach of the team, and is in charge of making sure the team is adhering to the scrum theory, practices and rules. As a scrum master works with the product owner, he/she finds techniques to help manage the backlog, as well as facilitate scrum events. On the other hand, when a scrum master is working with the development team, he/she coaches the team to self-organize and remove development roadblocks.

Major tech companies like Amazon, Microsoft, and Adobe are using Scrum. To learn more about it, check out


University of Alberta (2020). Software Processes and Agile Practices. [Coursera Course] under the Software Product Management Specialization. Taken November 2020.

Patzelt, M. (2020). Scrum. [Video]. Embedded under the course study videos under the Week 3 of the Software Processes and Agile Practices Coursera Course. Taken November 23, 2020.

Agile Methodology: Extreme Programming (XP)

Here’s a quick review of the terms I have previously noted in my Coursera course: Software Processes and Agile Practices:

Software Process – models that you use to organize development into phases.

Software Practices – techniques or actions that you can use to help manage and track development

Methodologies – are defined groups of practices

Agile Practices and Agile Methodologies – practices and methodologies that are based upon the agile manifesto


One of the software development methodologies that adhere to agile practices is called Extreme Progamming. It is called as such because the practices applied here are taken from other methodologies but to an extreme level.

One fundamental component of this practice is all about client satisfaction. This means that the product manager and the development team will make sure that the client’s needs are met and that the client is as satisfied as possible. However, in a real world scenario, there are various types of clients and the practices of extreme programming does that.

Extreme programming values the following:

  • constantly delivering software
  • responding to change
  • effective team work
  • self-organization

Extreme Programming also focuses on these 5 aspects of development:

  • communication
  • simplicity
  • feedback
  • respect
  • courage

Extreme programming is also commonly defined by 12 basic principles. These are:

  1. Planning Game – the client and the development team work together to plan a product following these 3 basic rules.
    • They will come up with a list of new features that is expressed as a user story. Then, these will be converted to software requirements & client needs.
    • The development team will create estimates for how much effort they allot in the next iteration and how each user story will take to complete.
    • The client and the development team will then prioritize user stories, then decide when to release a working version of each feature.
  2. Small Releases – the release of the product has to be small and as frequent as possible.
    • The development team will plan with the client which features make good business sense and can be released early in the project.
    • The development team and the client need to find the right balance between what the client wants to complete and what can be developed early.
  3. System Metaphor – this is a metaphor that the team comes up with to describe the product to a non-technical person and what it does.
  4. Simple Design – here, the designs has to be as simple as they can be
  5. Continuous testing – the tests has to be written for a feature or requirement before the source code is written. This adheres to the test-driven development. The idea here is to use the tests as executable forms of requirement. There are 2 ways these features or requirements are tested:
    • Acceptance Tests – the client will test each feature of the overall product to see if it works as specified. These tests can be automated or they can be a script of user interface actions that a human follows.
    • Unit Tests – these are automated tests written by developers to test lower level functionality.
  6. Refactoring – this is all about restructuring the design of the code without changing the behavior of the code. It encourages responding to new changes.
  7. Pair Programming – two developers work side by side at one computer to develop and review the code. This way, the developments will more likely take calculated risks which can lead to innovation because they are not doing it alone.
  8. Collective Code Ownership – this practice suggest that the software product manager has to encourage the entire development team to contribute new ideas to any part of the product. This means that anyone can add code to any part of the product. With this, whether the product becomes successful or not, the whole team is responsible for it.
  9. Continuous Integration – this requires the developers to combine their code often and that all tests should pass 100% before and after the integration.
  10. 40-Hour Work Week – this is encouraging work-life balance among the developers, even with the most passionate ones.
  11. On-site Customer – this invites the client to be part of the development team and be around anytime to clarify and answer questions about anything that might come up.
  12. Coding Standards – this means that all developers code to the same standards. This means following a set of common code conventions.

In his first version of the Extreme Programming Rules, Don Wells has laid out 29 extreme programming rules; however, some of those rules are overlapping with the above 12 rules mentioned. There are management practices included in these 29 rules that is also interesting to mention here:

  1. Give the team a dedicated, open work space.
    • Work spaces should have multiple computers that belong to no one.
    • These work spaces should be located in the middle of the room and not along the walls to encourage the team to work together.
    • There should be a meeting table with white boards where the team can collaborate and brainstorm.
  2. Move people around.
    • This encourages communication and flexible work relationships. This means that everyone knows how to develop and operate all parts of the product.
  3. Change XP itself.
    • This means to fix extreme programming practices when it breaks. When something does not work, change it. By having frequent project retrospective meetings, it will be easy to determine what’s working and what’s not.

As the practice of XP has its benefits, it also has its weakness. These are:

  • The individual practices do not have as much value as the overall methodology. But sometimes, implementing all the practices is not practical.
  • XP is designed for small development teams.
  • There is lack of upfront planning with extreme programming. It does not encourage real upfront software architecture planning.
  • Difficulty to arrange an on-site client. In real world, clients won’t always be immediately available.

As such, extreme programming has many great practices for software development, but as a software product manager, it is important to find practices that work for the development team. This is just one of the many methodologies, but for sure, knowing a lot of this methodologies gives an edge for the team to implement what is effective.


University of Alberta (2020). Software Processes and Agile Practices. [Coursera Course] under the Software Product Management Specialization. Taken November 2020.

Patzelt, M. (2020). Extreme Programming. [Video]. Embedded under the course study videos under the Week 3 of the Software Processes and Agile Practices Coursera Course. Taken November 22, 2020.

Agile Practice: Continuous Delivery

All throughout the week, I have shared to you the most common software process models that a software product manager can best use for his/her product development. After the prototype is complete and once the product is ready for the client feedback, there are times when even if the prototype function well during development, it may not work as well for the client. To avoid this, it is an essential agile practice to automate the build of the prototype for testing, integration, and release of the product.

What is continuous delivery in the world of software development?

According to Stewart Hardy (2008), continuous delivery is the ability to get changes of all types—including new features, configuration changes, bug fixes and experiments—into production, or into the hands of users, safely and quickly in a sustainable way.

Continuous delivery allows the developers to deliver a product continuously, as it is being developed. Whenever a developer commits a code change, it will be built, tested, integrated, then released. The gap between the change and having it released is very short so it becomes noticeable for any problems that may arise. With this immediate feedback, the developers will be able to pinpoint immediately what went wrong and fix it in no time.

Further, continuous delivery prepares the product management team to release the product at any point, each to a specific channel or streams intended for different audiences for feedback. In order to support continuous delivery, the software product management team could use automated tools and these tools can be used to build and integrate the code, run tests, and package the product into a releasable form.

Test-driven development, usually used by large teams practicing continuous delivery, is an approach of writing tests before actually writing the code itself. The developers are actually solving the right problem by making the functionality they want. Here, the code is written, features start to take form within the product, and then with continuous delivery, the process is happening all the time and tested and fix immediately. If nothing breaks during the process, the prototype is ready for distribution anytime for testing by the users.

Check out this illustrated notes by Nhan Ngo continuous delivery:

See the source image
What is Continuous Delivery? – Continuous Delivery by Nghan Ngo


University of Alberta (2020). Software Processes and Agile Practices. [Coursera Course] under the Software Product Management Specialization. Taken November 2020.

Poulette, B. (2020). Unified Process. [Video]. Embedded under the course study videos under the Week 2 of the Software Processes and Agile Practices Coursera Course. Taken November 21, 2020.

Hardy, S. (2008). Continuous delivery: Introduction. [Article]. Retrieved on Nov 21, 2020 from