Lean Software Development – Part 1

I shall be breaking up the Lean Software Development Principles and share my thoughts from my experience.

All about Lean is to “Fail Fast” and “Continuously Improve” one step a time.

Lean Software Development Principles

  1. Eliminate Waste
  2. Build Quality In
  3. Create Knowledge
  4. Defer Commitment
  5. Deliver Fast
  6. Respect People
  7. Optimize The Whole

Let’s discuss each one of the principles.

Lean Principle #1 – Eliminate Waste

What is waste, and how do you identify it?

Some “Waste” are obvious, but other forms are more difficult to spot / solve. Some processes or conventions might seem wasteful, but actually provide real value elsewhere in the organization, or prevent other forms of waste from emerging later. Other activities may seem valuable, but actually do not really result in any real value.

Toyota identified 3 general forms of waste, which they called in Japanese – ‘Muda’ (meaning unproductive), ‘Mura‘ (unevenness, inconsistency) and ‘Muri‘ (over-burden, unreasonableness). From these, 7 particular types of waste in manufacturing was identified . The below table shows the software related equivalence to it:

Types of Waste

Manufacturing Software Development
Over-production Unnecessary Code or Gold-Plating
Unnecessary transportation Bureaucracy – Slow or Ineffective Communication
Inventory Work Done Partially
Motion Unclear or Volatile Requirements
Defects Defects and Quality Issues
Over-processing Starting more than what can be Completed
Waiting Delay in the software development process; Task Switching

Retrospection’, a common agile development practice, the team meeting after each short iteration to discuss what went well, what didn’t, and what could be done differently in the next iteration. This iterative process of learning and continuous improvement is an important part of identifying waste and eliminating it.

Traditional software development and project management methods advocate a ‘lessons learnt’ process, but it generally takes place at the end of a project. By this time, things are forgotten, people have changed, the context has changed, and the team may be ending to move on to another project. As a result, the team may never really get a chance to put these learnings and changes into practice.

With agile development, these retrospectives enable the team to make small improvements regularly, and tackle changes in manageable, bite-sized pieces that can be action-ed immediately.

Identifying and eliminating waste should not be a rare event conducted by process re-engineering consultants every few years. It should be a regular process, built into regular iterations, determined as much as possible by the team, and tackled in small, timely steps.

Making improvements little-but-often in this way creates a culture of continuous improvement – a learning environment that organizations could potentially take the edge over competitors.

Hold regular retrospectives, foster lively but healthy debate, critical but constructive feedback, and try to drive meaningful and actionable improvements that actually helped frequent identification and, more importantly, eliminate waste.

Another fact is that Quality issues result in all sorts of waste. There’s waste in testing the code more than once. Waste in logging defects. And waste in fixing them. As a result, lean principles specifically seek to address this point.

Minimizing the gap between builds also reduces another form of waste, that is integration.

Lean Principle #2 – Build Quality In

In agile methodologies, Scrum and Extreme Programming (XP) are great examples of lean thinking in action

Firstly, there are quality assurance processes designed to avoid quality issues in the first place like Pair Programming and Test Driven Development.

Pair Programming seeks to avoid quality issues by applying the minds of two developers to each task. The task benefits from the collective, combined experience of two developers instead of one, often resulting in better productivity as they see solutions that on their own they might not have done. Another positive outcome of Pair Programming is improved quality, since one person can be thinking slightly ahead of the other, catching issues before they occur.

Test Driven Development avoids quality issues by writing tests before writing code. In the simplest form, writing down the test conditions for each feature just before it’s developed. If the developer knows how it’s going to be tested, they are much more likely to write code that addresses all the scenarios. In its more sophisticated form, Extreme Programming advocates stubbing out the code and writing automated unit tests for each of the test conditions before actually writing the code. The developer then writes the code to pass the tests.

Both of these practices come from Extreme Programming and both seek to prevent quality issues from occurring.

Constant Feedback – Inspect and Adapt

By doing development in small incremental steps, through close collaboration, and by developing in small iterations, the lean method provide the opportunity for constant 2-way feedback between the Business and the team. This feedback can be immensely valuable, inspecting and adapting the product every single day in order to ensure the right level of quality and the right product.

Minimize Time Between Stages

Another important technique for building quality into the development process is to minimize the time between development, testing and bug fixing. Rather than logging bugs, deal with them immediately. Logging bugs in a lot of cases is in fact waste. If the tester can test the code as soon as it’s developed, and the developer can fix any bugs as soon as they are found. On the other hand, a long gap between producing the code, testing it, and before fixing the bugs results in a loss of continuity. A loss in continuity that causes delays from task switching, knowledge gaps, and a lack of focus.

Frequent Integration

Lean development methods also advocate doing regular and frequent builds. Typically, daily nightly, if not hourly, through continuous integration, with code integrated into the overall system, built and automatically unit tested as soon as it is checked in. On large waterfall projects, the integration and regression testing phases of the project can be very lengthy. Regular builds and frequent integration avoids that problem.


Lean development methods also encourage automated regression testing. This practice is not unique to agile development, but is another way to reduce the effort associated with finding quality issues before they occur in a live environment. This is admittedly the last stage, but quality assurance is built into every step in the process.

This is how Scrum and XP have translated lean principles into practice in software development and built quality into the process.

Managing Trade-offs

A gentle warning – Quality is only one dimension of the project – the others being time, cost and scope. Sometimes there will be commercial reasons to trade-off quality against other factors, or to watch out for situations where attention to quality costs more than the issues you are trying to avoid.

One example of where agile methods acknowledges this in principle is the acceptance of rework (‘refactoring’) as a result of not having a detailed spec and complete design up-front. Many people have found them to be counter-productive and hence agile methods were born.

Similarly, if you are working on fairly low-complexity visual components that have a low impact, it may be worth spending less time on quality assurance as the risk of quality issues occurring, and the impact if they do, is much lower. Naturally this is a judgement call and unfortunately it can be very hard to know where to draw the line.

In summary…

Obviously, Quality is extremely important, or else all sorts of waste are inevitably created further down the line. Build quality in. Build it in as early as possible in the process to avoid quality issues materializing. And build it in throughout the development process, not just at the end.

Other principles shall be discussed in Part-2 of this blog post.


One thought on “Lean Software Development – Part 1

Add yours

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Create a free website or blog at WordPress.com.

Up ↑

%d bloggers like this: