To understand how an agile project management methodology like scrum and the DevOps mindset work together, let's look into an arbitrary software development team called the dream team. I will tell you how they use scrum with their DevOps practices like a small story so that it wouldn't feel like you are trying to learn these concepts by reading an article.
The dream team was tasked with building an online bookstore. Their vision was to create a platform where readers could easily browse and buy books.
In the team, there was a Product Owner, a Scrum Master, a UI/UX designer, a couple of developers, and a database engineer. They started their journey with a meeting led by the Product Owner, who had a clear idea of the features needed for this platform. This list of features, known as the product backlog, included user authentication, a book database, a search function, a shopping cart, and a payment system.
The Product Owner, the Scrum Master, and the rest of the team then held a sprint planning meeting. After a productive discussion, they decided to focus on user authentication and the book database for their first two-week sprint.
Using Visual Studio as their IDE, the developers dived into coding. One developer began setting up the user authentication system, while another started building the database for the books. Simultaneously, the UI/UX designer began crafting an intuitive and visually appealing design for these features.
As they made progress, they regularly committed their changes to GitHub, ensuring their work was saved and shared with the rest of the team. They created separate branches for their features, and once they felt their work was ready, they made pull requests. Their colleagues reviewed the changes, provided feedback, and eventually, the new features were merged into the main branch.
An automated build process, part of their DevOps practices, was triggered each time they merged into the main branch. This process compiled the code, ran tests, and alerted the team of any issues or bugs that needed to be fixed. This was their Continuous Integration practice in action.
Every day, they gathered for a short stand-up meeting. Everyone - from the UI/UX designer to the database engineer - shared their progress, discussed their plans for the day, and highlighted any obstacles they were facing. The Scrum Master ensured these meetings were efficient and that any issues were addressed promptly.
Once the new features were fully developed and tested, the team used their DevOps practices to automatically deploy the features to a staging environment, and then to the production environment.
The end of the sprint arrived, and it was time for the sprint review. The team demonstrated the new features to the Product Owner and other stakeholders. They received valuable feedback and adjusted their product backlog accordingly for the next sprint.
After the sprint review, they held a retrospective meeting. They reflected on their work, discussed what they had learned, and planned how they could improve their processes and efficiency in the next sprint.
With the first sprint completed successfully, they launched their online bookstore to the public. The team watched as users started to register and browse through the available books. They used monitoring tools to track the application's performance and collect user behaviour data in real time.
Shortly after the launch, they noticed a bug: the search function was not returning accurate results for some specific queries. The team quickly prioritized this issue in their product backlog and fixed the bug during their next sprint, deploying the fix using their established DevOps practices.
In addition, they discovered from user feedback and data analysis that users were keen to have a book recommendation feature based on their past purchases. This was a feature they hadn't considered initially, but it seemed to be of great value to their users. Excited by this opportunity, they planned and discussed this feature in their next sprint planning meeting.
The team felt a renewed sense of purpose as they prepared to embark on their next sprint. They knew their journey of improving and expanding their online bookstore was far from over.
Through Scrum and DevOps, they were equipped with a reliable and efficient method of continuously delivering value to their users.
The team started the new sprint with this potential feature in their sprint backlog.
The UI/UX designer began sketching out how the recommendation feature might appear to the user. Meanwhile, a developer started researching the best algorithms for book recommendations. Another developer thought about how to integrate this new feature with the existing codebase, and the database engineer planned for any changes needed in the database to support this feature.
As usual, they used GitHub for version control, committing and pushing their changes to their feature branches. They continued to review each other's code, catching potential issues early, and ensuring quality code. The automated build process continued to check that the new code integrated seamlessly with the existing code.
In their daily standup meetings, they discussed their progress on the recommendation feature, and the Scrum Master helped resolve any impediments the team encountered. Once the feature was fully developed and tested, they deployed it to the staging environment and then to the production environment. Thanks to their well-established DevOps practices, this was a smooth process.
As the sprint came to an end, they held their sprint review and demonstrated the new recommendation feature to the Product Owner and stakeholders. They received positive feedback and further suggestions for improvement.
During the sprint retrospective, they reflected on their successes and challenges and discussed improvements for the next sprint. One of the developers suggested using pair programming in the future to enhance code quality and accelerate problem-solving, which was well-received by the team.
The updated online bookstore, now with a book recommendation feature, was relaunched. The team closely monitored the user responses and application performance. They were thrilled to see that the feature was well-received, and users were finding it helpful.
As the team prepared for their next sprint, they felt a sense of accomplishment. They had not only delivered a product that was working well and providing value, but they had also managed to respond to user feedback and add an entirely new feature. They had truly embodied the principles of Scrum and DevOps, and were excited to continue their journey, knowing that each sprint would bring them new learnings, new challenges, and new opportunities to deliver an even better experience for their users.
This is an example, of how scrum can be used with DevOps practices. While scrum focus on the project management aspects, DevOps is more about how CI/CD pipeline is automated and bugs are caught as early in the development cycle as possible. If we can combine the two, it could greatly enhance our teams' ability to deliver in high-pressure situations efficiently.
Comments