Table of Contents
The lean manufacturing principles (or lean production) originate from the manufacturing industry and has proved to be a useful insight for several businesses. It was in 1988 when the President and CEO of Hyundai Motor America, John Krafcik, coined the term ‘Lean’. Toyota Motor Corp. inspired Krafcik as he saw how they improved their automotive production via their famous ‘The Toyota Way’ in the 1930s. According to this system, any action is useless if it does not improve a car’s performance. Now, the software industry is also enjoying these principles and call it Lean Software Development (LSD).
Toyota argued that ‘inefficient procedures’ are actually waste of resources and ultimately removed them from its manufacturing process. Software development and the IT industry can also adopt this philosophy to optimize software production, minimize ‘waste’ and maximize customer relationship. In short, lean production is more than just a way of producing goods; it has become an agile model of conducting business.
If we research on “lean manufacturing principles” regarding software development, Lean Software Development (LSD) Principles often appear on search pages. These principles are a mirror image of what Toyota created for themselves but moulded for IT & web development works. In other words, LSD is an agile framework that optimizes development time and resources. It is a method that reduces wastage and delivers exactly what clients require.
Why Choose Lean Software Development (LSD)?
The major highlight of lean development, or LSD, is its continuous focus towards users. Software companies should make minimum viable products (MVPs) based on their research and then validate what they learnt after launching the product. Software development projects can typically cost between US$ 250,000 to 10 million. Hence, these companies must justify spending any amount of money by producing strong metrics that are easy to read, actionable, quantifiable and predictive. Through lean production, vague terms like ‘customer satisfaction’ have no room in discussions. Here, arguments rather revolve around specifications like ‘units processed per person per day’. In a way, lean development creates a ‘Why’ question for every process to make overall work more efficient. For example,
“Why are we doing this?”
Let’s look at a few benefits and drawbacks of lean software development:
Advantages of Lean Software Development
- Creates a streamlined approach to ensure delivery of more functionalities in lesser time.
- Companies see cost reductions due to elimination of unnecessary activities.
- The development teams are free to form decisions, thereby boosting team morale.
Disadvantages of Lean Software Development
- The lean software development is incredibly dependant on teams. Their progress directly affects its scalability.
- LSD requires a strong practice of documentation. Teams may incur development mistakes if they do not give attention to tracking their work.
Even with its drawbacks, many businesses have found the lean software development methodology to be an incredible work procedure for software development. It is all about increasing efficiency, and one of the ways LSD does that is by strictly cutting away inefficiencies. These are processes that do not directly contribute to the final product and can be trimmed away without losses. However, to achieve a full implementation, software development teams must be top-notch and have an organized approach towards documentation.
Integrating Lean Principles With Software Development
It took several years after researchers formulated the Agile Principles when concepts of lean manufacturing for software development came out. There are seven lean development principles, or Lean Principles, as we call them:
1) Eliminate Waste
A classic problem in manufacturing; teams must reduce resource wastage. It is no surprise that the key principles of lean software development start with a discussion on a major principle: eliminate waste. Waste, in terms of software development, are partial codes, wait-time, added features, etc. Consider the bolded example:
Suppose the clients give product managers between 6 to 18 months for product release. The developers are most likely to add requirements to the list that the clients can consider extra because there is ample time. Under the Pareto Principle, just 20% of that coding will provide 80% of the value to end-users. The remaining 80% will only provide 20% of the value. This is because these features are not requirements from the clients and no way do they add value either. This trend is similar in the case of delays in task transferring as well.
2) Build Quality In
Whenever developers find defects in late-testing cycles, it most certainly means that the software development process is faulty and requires a check. Defects in late-cycle testing are more costly than those found at the start, or after engineers inject codes in the main branch. Lean software development promotes a test-driven approach, and through its techniques, eliminates the need for bug fixing and waiting time. It encourages continuous integration tests to enable efficient defect detection, removal and prevention.
However, working on defects is also a ‘waste’ process since a defective code is equal to incomplete code. One method to go around this is by using pair programming where one team member complements the skills of another. Automating routine tasks as much as possible can be a second one.
3) Create Knowledge
This principle in lean software development talks about sharing knowledge. The principle encourages developers to produce a convenient format of sharing their findings of their product. This information sharing aids in creating valuable insights which help teams avoid repeating mistakes in the future.
The principle advises development teams to proceed step-by-step through a project, slowly learning more and more of their client’s requirements. This ensures designing a perfect architecture of systems to support client needs. Teams that try to anticipate all requirements at once and continue with their perceived requirements eventually have to face design and requirement changes. Such teams will feel group inertia regarding design improvements where they will feel rigidness in changing designs and making amends.
4) Defer Commitment
Businesses tend to misinterpret this principle, but it is equally important as the rest and InvoZone understands this as well. The essence of this principle states that software developers do not have to make a final decision until they gather sufficient data. Even then, this principle requires to be open to changes and making room for adjustments. For this, teams should continue to gather new information by considering business requirements as well.
It is important to note that here planning does not mean that you fully commit to the program-at-hand. Rather, businesses should prepare contingency plans, sometimes even make inevitable changes and restructure their processes over critical decisions. In this case, committing to a long-term plan might not be a healthy decision. This is where a famous quote comes to the mind:
“…plan thoughtfully and commit sparingly.”– Implementing Lean Software Development: From Concept to Cash (Pub: Sep 06)
5) Deliver Fast
This is perhaps the most misconceived notion among the seven lean software development principles. Developers must realize that the action to deliver fast does not call for delivering at the cost of quality. Conversely, it also does not state the need for continuous work to gain a high-quality solution. In actual, the basis of this principle is on the simplicity of the design. Think about the MVP approach; it is necessary to work on required designs, make them high-quality and practice continuous feedback and testing. Finally, move towards the development of new functions, but make sure if the client even desires such a move. For product owners, they can look into market trends to form a conclusion.
In the above particular case, you can notice that the speed of delivery is ultimately dependent upon market. ‘Deliver fast’ is all about requiring team members to feel the empowerment of finding the most efficient way of doing a job. Only then will they be able to make the necessary adjustments in the software development process.
6) Respect People
When teams are working alongside to reach a single goal, workplace relationships tend to become a factor in development process. Lean software development addresses this as well and calls for:
- strong team communication,
- healthy debate & feedback,
- energized brainstorming sessions,
- and professional ethics.
This system starts right from onboard hiring, working and goes until firing/downsizing. The principle calls for the capacity where teams feel empowered enough to be able to self-direct themselves using decision-making powers.
7) Optimize The Whole
Here, it is crucial to realize that the whole multidisciplinary team is responsible for delivering products with a single goal in mind: maximizing Return on Investment. This will not only optimize the overall process but will improve results as well.
If businesses measure teams on their productivity, then the teams might rather send as much code to the testers as possible. With a minimal responsibility towards quality, testers would either take a long time to deliver feedback or would not initiate thorough test procedures. Ultimately, the overall quality of the code will decrease. The term ‘optimize the whole’ actually means ‘optimize the entirety, instead of a single process’. The final principle of lean software development is about encouraging teams to focus on their ultimate team goal. It requires a prudent trade-off between speed, quality and all other aspects of software development. There must be an equilibrium, and developers must aim for it.
It was Mary and Tom Poppendieck who first brought a new perspective for agile software development through lean development. The Lean Software Development Principles draws a parallel between agile development and lean manufacturing from automobile manufacturers, like Toyota. Interestingly, agile methodologies like Crystal, Scrum, Feature-Driven Development, and Extreme Programming are all guided by principles of Lean and Agile development as mentioned in the Agile Manifesto. Ultimately, Lean development exists for the very purpose of helping developers raise their work efficiency and help them grow.