Sprint training
How to improve your agile process in three weeks?
There are several methods to work as an agile team. Most of us are working in a scrum process or use methods of the Scrum methodology. But how to improve the process?
During daily work, it is often very hard to review the advantages of changes to the process. Everybody is focused on getting the job done. The recognition of effects triggered by a change to the method is often not obvious.
Normally a Scrum Master helps the team with retrospectives and his input to improve the process. But it is still not easy to solve problems or evaluate new ideas.
Because of the need to improve things nonetheless, we tried a sprint within the sprint.
A sprint in the sprint?
The idea behind the sprint in the sprint was to try out a new working method during a timeboxed mini sprint beside daily work.
The setting was intended to be as following:
- First day: Sprint planning of one closed small task during one hour
- Three Sessions consisting of 15 minutes code review, one-hour coding and 15 minutes refinement for the next session
- After this strictly timeboxed sessions, the task should be finished
Luckily, at LV 1871 we, as a team have the time to focus improvements to the process and personal learning.
What did we want to train?
We often talked about the chances and advantages of cutting down stories to a smaller size and work massively parallelized on bigger tasks.
We never tried this during work, so we decided to try it this way.
Normally we don’t have tough deadlines. So we always have the chance to reach a near 100% solution. In this mini sprint, we wanted to try to build a running solution as soon as possible and refine it during the other sessions.
So, the main goal was to end up with a running solution after each timebox.
Finally, the team should also train angular development.
1. Sprint planning
We started with the presentation of the user stories. To have some fun, the task was the implementation of a Sokoban (a game) clone.
The user stories described the target environment and runtime, the rules of the game and any assets. Finally, there were two components to be implemented. Product owner and architecture owner were not available and not involved at all.
The team refined the stories and decided to start with a pure frontend solution without any network communication.
In total, the team defined 6 stories for 6 developers for the first session.
2. Implementation
Two members of the team missed the first planning, so the team had to introduce the tasks to them.
Hard work. The tasks were very abstract and finally not defined well enough. 15 minutes lost. Lesson learned.
Implementation started.
Close cooperation needs well-defined APIs!
The next obvious recognition has been the fact that close cooperation requires the definition of APIs as exact as possible on the story level. Or otherwise, to work in a defined order starting with the definition of the API.
The stories were describing behaviour and not APIs. So finally, because of the spatial separation, the team implemented two APIs with a small deviation.
Get David Ibl’s stories in your inbox
Join Medium for free to get updates from this writer.
On the last day, the team build the first running version. The game was playable, but the backend, to store high scores, was not bound to the frontend.
3. Review
Finally, we made some interesting recognitions from this mini sprint.
API definition is the base of cooperation
When it comes to cooperation, single tasks should describe how components interact with each other much more detailed than how they behave.
The base of every interaction is some kind of API. If it is possible to separate tasks by network communication it is mostly easier to define the interaction by defining a clear network API.
But even on a component or class level, it is totally necessary to define an API by defining a clear, complete data model to ensure the possibility of efficient cooperation.
If it is not possible to define the data model, we have to organize the order of tasks in some way to stay efficient. Otherwise, the friction-loss will be very high.
From a real operational level, a high number of merge requests not going on fast forward are an indicator for inefficient ordered tasks or an unclear API or data model.
Architecture is a necessary artefact to create stories
The general architecture should be clear before starting the implementation.
Architecture means the boundaries which define the general structure and organization of code as well as the used platform, framework and platform-related details like security, logging and form of communication.
Design patterns and code-style are necessary artefacts of architecture to ensure collaboration on a code-basis.
Personnel scaleability has a limit
There is a hard boundary when we try to scale a team.
The more people working on a task in parallel, the more details have to be defined prior implementation. If the time used to describe tasks and their APIs becomes too high, scaling by involving more developers seems to be ineffective.
The most important recognition was a minimal story size for our team, which enables us to be as efficient as possible.
Building an MVP is tough mental work!
What the hell is an MVP?
This is a question which has to be answered at the beginning of every project.
Mostly we have to understand what the most important user requirement is.
But finally, an MVP in sense of a minimal viable product can be seen from a business objective as well as from a technical point of view.
The best result can be reached when defining a minimal architecture which allows us to develop better solutions in iterations.
In our example, the central user requirement is not the backend after all. A playable game is a central requirement.
To build an MVP we have to define architectural milestones, starting with a solution which can be transferred to a better state in every iteration without re-implementing everything.
During the review, we discussed why the team did not accomplish an MVP in form of a playable game after each session.
- The tasks were too big for the first day (wanted too much, especially from an architectural point of view)
- Created graphics (wrong focus)
- Unclear target (an MVP is more a subjective impression than a defined state)
Finally, the mini sprint gave us the possibility to get a first impression of how we could improve our work.
Especially implementing in milestones starting with an MVP will be an objective of our work in the future.
Further, we still have to define some kind of agile architecture to support improving solutions step by step without heavy migration efforts.
Feel free to play the final game:
Within the next article, we will have a look at the architecture of this game and how reactive programming can help us building an MVP of a UI tool.









