Agile is Worth Improving

Hello, my name is Max Nechaev. I hold the positions of technical leader and team leader at Snoonu and am the founder of a startup. Today I want to share with you our experience in optimizing Agile processes. In this report I will tell you about the problems we faced, what methods we tried and what results it brought.

We experimented with different approaches and finally found optimal solutions that significantly improved our work. My goal is to share these findings with you in the hope that they will help your teams achieve better results.

Our Challenges

The first step in our improvement journey was to conduct a comprehensive analysis of our current situation. I personally met with each team member and conducted in-depth interviews to understand exactly what challenges we were experiencing. Here are some of the key challenges that were identified:

• Lack of understanding and analysis of epics and tasks prior to implementation.
• Lack of full immersion of all team members in the context of epics in the early stages of the project.
• Superficial reading and analysis of epics and tasks.
• Misunderstanding of task requirements, which led to the implementation of incorrect behavior.
• Insufficient time allocated for architectural planning.
• Delays due to waiting for actions from external departments such as QA and marketing.

Once these challenges were clearly identified and understood by all team members, I set about developing a strategy that would allow us to address them.

In the next part of the report, I will elaborate on the changes we made and how they helped us improve our work processes.

Preparing for Food Grooming: Requirements and Preliminary Tasks

Prior to the food grooming session, I have instituted a number of mandatory requirements that aim to maximize the preparation of each team member for the upcoming discussion. One of the key requirements is that every team member must study the epic. This is important to ensure that everyone fully understands the essence of the epic and its business goals, which will allow the product grooming to discuss not only technical details but also the strategic importance of the project.

Each developer, in addition to understanding the overall goals, should prepare a preliminary plan of their actions. This includes an assessment of possible solutions and approaches that will be proposed and discussed at the grooming. Preparing such a plan helps developers not only to structure their ideas but also to assess the potential risks and challenges that may arise in the course of project implementation.

In addition, each developer should generate a list of questions to help clarify nuances and obtain the necessary information to accurately work on the project. These questions should be aimed at identifying any ambiguities and potential problems in the planned implementation so that they can be addressed and resolved during the planning stage.

If the epic is not clear or detailed enough, it should be sent to the product manager for revision. This approach ensures that only epics that are fully ready for implementation will be accepted into the workflow, thus eliminating risks associated with possible misunderstanding of the task or its goals.

To ensure effective interaction and prompt resolution of arising issues, each team member is provided with a list of contacts of all interested parties. This allows you to quickly contact the right specialists to clarify information or get additional explanations, which is very important for dynamic and coordinated work on the project.

Thus, systematic and thorough preparation for product grooming not only increases the overall understanding of the task by the whole team but also significantly accelerates the development process, reducing the number of potential errors and misunderstandings at subsequent stages of work.

Stages between product and technical grooming: Preparation and responsibilities

The period between product and technical grooming is critical to guarantee the success of the project. During this time period, certain procedures and requirements are put in place that all team members must adhere to.

As a technical leader and mobile developer, I have introduced a new practice requiring my presence at every technical grooming. Previously, I had neglected this aspect by not attending grooming sessions conducted by the backend development team. Now, as part of the new process, it is my responsibility to participate in all technical discussions and oversee the process to ensure effective communication and integration between all areas of development.

Before technical grooming, each developer must thoroughly understand the code base of all functionality (features) to be worked on. It is important not only to understand where and what needs to be added or changed but also to realize the reasons why these changes are necessary. If a developer has questions, they should actively seek answers, whether through discussion with colleagues or by searching for information on their own on platforms such as Google or YouTube.

In addition to developer responsibilities, I've also introduced new requirements for testers. Each tester is now required to prepare all test cases prior to product grooming. In addition, testers are actively involved in evaluating and moving tasks on the Kanban board, which allows them to be as involved in the development process as possible and provides better preparation for technical grooming.

The outcome of these activities is that every developer and tester now has a clear and concise view of their tasks. They know exactly what needs to be done, where, and how it needs to be accomplished. This ensures that they are better prepared and ready to discuss epic at technical grooming, which significantly increases the likelihood of successful and efficient task completion.

Technical Grooming: Digging Deeper into Details and Collective Decision-Making

Technical grooming is a stage where each developer not only already owns all the details of the upcoming implementation, but also actively participates in the collective discussion of the epic's architecture. It is important that this process is collaborative: it cannot be the case here that developers just listen to the technical leader's decisions without the opportunity to contribute. An epic team should have discussions, express different opinions, and jointly arrive at the best technical solutions.

At technical grooming, each developer approaches with a list of questions that they have prepared beforehand, which facilitates a deeper and more productive discussion. This stage not only strengthens teamwork but also helps each participant better understand the task and identify potential challenges.

The main outcome of technical grooming is to reach a common understanding and a unified epic solution. This applies to all aspects of the implementation: from the basic logic of the work to the consideration of extreme cases, which have already been previously worked out by the tester and included in the common list of scenarios under consideration. Team discussion allows to identification of these cases as well, which minimizes risks in further work on the project.

Then, based on the discussions, the necessary number of subtasks is formed for the quality and complete fulfillment of the epic. This is also where these tasks are evaluated, and it is important to emphasize how this is done correctly. Correct task estimation is based on the following components:

1. Awareness of Requirements: A complete understanding of all the details and requirements of the project.
2. Implementation Understanding: Clarity on exactly how the technical aspects of the epic will be implemented.
3. Accounting for embedded risks: Anticipating potential problems and incorporating time to resolve them into the overall work plan.

This formula helps to accurately estimate the time and resources needed to complete tasks, which is key to successfully meeting project deadlines and budgets. Thus, technical grooming not only improves the understanding of the task by all project participants but also optimizes the development process, making it more predictable and efficient.

After completing all tasks of the epic

Having completed all the tasks included in the epic, we move on to the next stage - project realization. After implementation, the entire process moves on to the critical stage of code review. At this stage, it is important to realize that the responsibility of code review lies with the developers. Each developer should actively participate in this process, encourage and, if necessary, push his colleagues to code review. This means that he should not only submit his code for review but also make sure that his colleagues have done their part in a timely manner.

The code review must be done within strict deadlines - no later than 24 hours after the developer completes the task. This rule keeps the pace of work high and ensures that the project moves forward without unnecessary delays.

We have also introduced mandatory independent code testing by each developer. This means that each developer must realize that he is fully responsible for the quality of his code, and this is not shifted to the shoulders of the tester. A developer must thoroughly check his code for errors and make sure that all the functions work correctly before the code is sent for testing.

This approach does not exclude but does not duplicate testing of the code by the tester. Self-testing by a developer is not an additional burden but his direct responsibility. Well-tested code reduces bugs and speeds up the development process, which ultimately results in saving the company time and money.

Epic should be self-tested by the developer before it is sent to the tester. The main goal here is to minimize the number of possible code returns for revision and reduce the time needed to fix errors. Time is one of the most valuable resources in software development. The more efficiently time is used, the less money a company spends, and this directly affects its profitability. Optimization of working time not only improves the company's financial performance, but also contributes to faster delivery of the product to the end user, which, in turn, improves customer satisfaction and enhances the company's reputation in the market.

Every step in the development process, from self-testing to code-review, carries a key importance for the success of the entire project. Thorough testing and optimization at each of these stages is the key to a quality and successful release of a product that will meet all the requirements and expectations of both the company and its customers.

General Results

Now let's talk about the results we came to and what each developer on our team should realize. It is important to realize that everyone has a big responsibility. Developers should not just wait for clarifications from the management but actively try to understand the requirements from the very beginning of the project. This understanding should come during the planning and implementation phase, every developer must realize this.

Understanding to start with implementation before code is written is critical, as it greatly affects the accuracy of the estimates of lead times. Many developers put this point off until the last minute, which is a mistake. It is necessary to deal with it from the very beginning so that the process of writing code is as efficient and high-quality as possible.

Also, a great responsibility lies on developers in terms of estimating time for tasks. Each of them has to estimate exactly how much time and resources will be required to perform a particular task, and it is also their responsibility to do it on time and accurately.

In addition, the responsibility of developers also extends to code reviews. Expectations in this aspect are as important as active participation in the code review process.

Every developer is responsible for the quality of their code and therefore self-testing is a must. All developers should test their code before handing it over to testers.

I would recommend creating more tasks within each epic for each platform. For example, one task can be dedicated only to analyzing requirements, and another to investigating possible ways to solve problems. Of course, you should also allocate tasks for writing test cases to be used by testers. In addition, it is important to create separate tasks for self-testing on each platform.

I also recommend creating a schedule each week to meet with the team. This has made our workflow much easier, we have become more accurate in our estimates and overall the process has become clearer and more enjoyable for all team members. We now run every epic through established processes because it's as efficient and productive for the team as possible. Everyone feels comfortable and enjoys the work.

The meeting schedule for the week is as follows:

• Wednesday: analyze upcoming epics.
• Thursday: product grooming and creating research tasks.
• Friday: task research, code review, architecture planning.
• Monday: technical grooming and creating subtasks.
• Monday: planning for the week.

I hope this article was useful for you, as well as for our team. Share it with your colleagues if you find something valuable. Thank you for your attention and I wish you all a successful day!