👇 (This is the same intro for all the lean waste posts. If you have read it already, scroll down for 4 paragraphs) 👇
We waste time all the time. Small unimportant tasks. Procrastination. Looking at nothing (this one is not really a time waster if it clears your head). The world is filled with traps that make us waste our time, and some of them we already know how to detect and adapt to them.
Lean Manufacturing talks about the 7 lean wastes, these wastes can also be mapped to software development.
During these next 7 days, I will pick up one of the wastes and investigate the following questions
- Why does it impact our work?
- What could be the causes of this?
- How can we measure it?
- How can we avoid it?
For today, the focus is Hand-offs. These can come in the form of documentation, extra training or meetings.
I need you to create a functional document, then I will read it, create my technical document and give it to someone else. Sounds familiar?
When we are all done, we will create user manuals and run-books for the team that will maintain our project. To make it easier for them, we will have several meetings where we explain what we did and how it runs.
Sounds like a lot of work? That is not even the worst part. This whole process follows the assumption that nothing, absolutely nothing, will be lost in translation.
Code is like a good joke, if you have to explain it, you are doing it wrong.
Add this to a developer working on more than one project, and you have the trifecta.
Hand-offs that need to happen when we switch from project to project, to keep the team informed. Task-switching by moving from one task to the other, in some cases, several times a day. Partially Done work, because you never finish what you start. Keep jumping from one task to the other.
Why does it impact our work?
- Information may be lost on the hand-off chain
- This requires extra effort in the form of meetings, more documentation, and possible training
- If we use documentation as the only source of hand-off, there is a limit of what can be represented in text and diagrams. Try teaching someone to ride a bike by reading a bike riding book.
What could be the causes of this?
- Teams don’t own what they do
- Too many gates to your process. For example, if you are using the waterfall way of working.
- The hidden hand-off is when a developer passes the code to a tester to test.
How can we measure it?
- # of sign-offs in your process
- # of extensive documents that your team needs to produce for other teams.
- QA specific tasks. UAT team.
- Time spent on the steps of your process that are not done by your development team.
How can we avoid it?
- Try to reduce the number of hand-offs, start with the easier ones first (gates on the development workflow)
- Shorten your feedback loops with your stakeholders.
- Get cross-functional teams that can develop and test.
- Use tools to facilitate communication that is not in a written form.
- Do proper technical documentation on your code, PR’s and so on.