Work SMART, get LEAN!
Lean software development is a disciplined agile practice for optimization of value stream within the application and software development domain.
Lean manufacturing is wrapping up logistic and product manufacturing. Interacting with suppliers and customers is mandatory in the process. These practices are deeply bound with some core values of Agile software development and can be easily mapped onto the agile software development stream. Adopted from lean manufacturing of integrated socio-technical Toyota Production system and its approaches, originally it was called “just-in-time production.”
What does it bring into a real project?
What are the pros of integrating lean development into a company policy?
The lean software development provides core techniques for evaluating, optimizing, empowering and analyzing the whole product from its early stages and building continues delivery. All kinds of projects, despite their size and scale, can find approaches of lean development very useful for its needs. Lean development stream is built upon seven core principles:
- Eliminating waste
- Amplifying learning
- Creating knowledge
- Delivering as fast as possible
- Empowering the team
- Respecting people
- Seeing and Optimizing the whole
Now let`s consider them in detail.
1. Eliminate waste
The first and the major step in eliminating waste is to recognize it at first. A waste in software development can be described as any activity that does not directly add value to the product. At the very beginning, all the features should be filtered by necessity. The worst thing is to build the wrong feature or product.
2. Amplify learning/Build in quality
No defects! No excuses! All issues should be fixed as soon as possible to integrate to the next steps. All the fixes in the future will not be so effective. Create documentation for everything. No meetings or calls without should be held without documenting them afterward. The only discussions that may not be documented are the ones during your FIKA. There are a couple of practice to start with: Test Driven development, parallel code review, confluences, tickets, etc.
3. Create knowledge
Building knowledge on the project is one of the key factors to consider for a long run. It might be even more valuable than planning on all possible stages.
4. Decide as late as possible
Starting a product is hard! And you will encounter challenges during every phase. The main reason is that it is always associated with some uncertainty. On the early stages try not to make any assumptions, based on uncertain assumptions and predictions.
5. Deliver as fast as possible
One of the biggest mistakes is to hold a product in a closet, hiding it from people. The faster delivery – the better. Use focus groups to analyze. Don’t create a full, complete specification for the project. No need to plan the product to its final phase before you release it. It is always better to build small decentralized modules, scale them up into MVP and release to collect feedback. Analyze your team capacities. Start as soon as possible!
6. Respect people
Don’t overcontrol your team! Respect all members and trust them. Don’t tell developers how to do their job. Motivate them and delegate responsibilities to them.
7. See and Optimize the whole
To be really effective you have to see the whole picture at its scale. Understanding high-level business processes is a necessary aspect! Build a software product and delivering it are not enough – all interactions with customers should be analyzed. All defects should be found and fixed. Use tools available on the market to do so. Invest in analyzing the market and your product interactions.
In the next articles, we will describe all practices and process in more details.