Lean methodology benefits for development teams

The lean methodology has been a huge asset to several different industries, but the techniques and strategies it implements have never been more pertinent than in the field of software development.

This methodology hasn’t only made projects cheaper and faster but it’s also allowed for a whole new approach to problem-solving and created a fertile ground for innovation.

In this article, we’ll cover some of the biggest benefits of using this methodology in the development process, as well as give you tips on how you can apply it to your team. 

Let’s start!

The lean methodology makes the processes in software development easier, faster, and more accessible.

The main idea behind it is to reduce waste, but in the simplest terms, it guides you in identifying which processes and activities are slowing you down and eliminating them.

But let’s first define waste to get a better understanding of how lean principles streamline work processes. 

According to James P. Womack and Daniel T. Jones, authors of the book Lean Thinking, waste is any activity that consumes resources but creates no value.

However, waste comes in many forms, and to categorize it, we should first take a look at the history of lean methodology. 

The concept of lean methodology started in Japan in the 1940s as an industrial engineer and manager Taiichi Ohno began making changes in his division at Toyota Motor Company. 

The problem was that Toyota was competing against large companies such as Ford and GM that could afford to make a product once and sell it at a profit even though they had higher manufacturing costs than their Japanese competitor.

Therefore, Toyota, with Taiichi Ohno at the forefront, created a system of elimination of waste through the use of assembly lines and then further developed it into what is now known as the Toyota production system and lean manufacturing.

After Toyota’s huge success with lean manufacturing, Mary and Tom Poppendeick decided to examine how the same lean approach can be applied to software development.

In their book “Lean Software Development: An Agile Toolkit”, they drew on the seven wastes of manufacturing to come up with the seven wastes of software development.

As you can see in the picture, some of these wasteful practices include extra features, extra processing and documentation, delays, and defects, to name just a few.

If avoided, they can make the process of creating a product simpler, more efficient, and less time-consuming. 

To eliminate waste, lean methodology recommends that you examine all activities and processes and for each of them, ask the same question: “Could the end goals be achieved without it?”

If the answer is yes, it should be removed from the production cycle.

That doesn’t mean you have to cut out everything that isn’t absolutely essential, but you do have to be aware of how much time and energy are being spent on processes that don’t directly contribute to the product.

If a particular process or task is creating more problems than it solves, consider whether it would be best to eliminate it altogether. 

The way we develop software has changed dramatically over the last few decades.

Traditionally, the path to success in business was to meticulously plan out every aspect of the strategy and follow it to the letter. 

When each step was implemented, you were able to enter the software market.

The opposite of this approach is the lean methodology that enables fast delivery of the product—and, therefore, quick validation of the idea.

This way, you can get a minimum viable product (MVP) out in the hands of users as quickly as possible, which gives you much more time to refine the product and your business model.

As you can see in the picture, the minimum viable product (MVP) is a product that has just enough features to satisfy first users and give feedback for future development.

Instead of building a car from start to finish, you can first create a skateboard, present it to the users and improve the shortcomings of the prototype. 

In the following stages, you can build a bicycle, scooter, motorcycle, and eventually come up with a car.

That’s exactly what Dropbox did, and it dramatically increased its chances of success, rather than spending months or years on a big project that might not be successful after all.

Dropbox started as a video of a prototype, and below you can watch their first demo video of their MVP.

The co-founder of Dropbox, Drew Houston, used this video to introduce to the public the cloud storage app they were developing.

The response was overwhelming, and thousands of people got interested in his idea, resulting in a high number of pre-orders for the actual product.

Like Dropbox, many other companies use MVPs to speed up the delivery process, such as Buffer, Zappos, and Amazon. 

That’s no surprise, as MVP is a great way to quickly put the product to the market and test it without spending too much time, money, or effort.

Every company aims for quality, and with lean methodology, making it an indispensable part of your processes becomes increasingly easier.

The practice of releasing small chunks of work frequently allows developers to quickly adjust and improve the product throughout its life cycle, creating an overall better piece of software.

With traditional development, you can spend many hours implementing a feature, only to find that it didn’t fix the problem. 

This adds up to a lot of waste, and makes traditional methodology significantly less successful in comparison with, for example, lean and agile. 

That comes as no surprise because, when you’re working in small increments and implementing the necessary changes, you’re actually able to deliver a greater amount of quality than if you deliver a product in one huge chunk after it’s complete.

There are also numerous tactics that are used in lean methodology to ensure the quality of the product during all stages of the production cycle, and one of them is undoubtedly pair programming.

In pair programming, two developers take turns sitting at the keyboard and collaborating on writing, testing, and debugging the code.

What it looks like in practice can be seen in the picture below, which shows two developers at Workrise programming together in pairs.

It’s an effective way to ensure that high-quality work is being done because there are always two sets of eyes looking at the code and making sure that everything is in place.

Another great tactic you can follow is test-driven development, and the picture below summarizes perfectly what this method entails.

In a nutshell, you write a test for a piece of code before you write the code itself. 

Then, you check the test and write just enough code to make sure that it passes. 

You continue to do this by writing more tests and more code until the test passes and there are no bugs or other issues with what you’ve written so far. 

This process helps to ensure that your code is of the highest possible quality because it forces you to think about what you’re doing while you’re doing it.

Whatever method or technique you choose, the bottom line is that lean methodology builds quality into the product. 

It does this partly by ensuring that the product is always in a state where it’s good enough for users, and partly by implementing quality practices throughout the development process.

The lean principle is often expressed in terms of respect for people. Unfortunately, it’s something that many companies often overlook, to their own detriment.

Respect for people isn’t just about treating people well. It’s about learning how to get the most out of the team members in order to make them happier and more engaged.

In fact, through adopting the principle of respect for people, Toyota aims to foster a work culture that values innovation, teamwork, and trust.

These words emphasize that it isn’t possible to create anything worthwhile without the engagement of the whole team.

Toyota encourages its employees to think of themselves as part of a larger collective, working towards a common goal.

The same holds true for software development too. In lean teams, there is often a great sense of camaraderie between team members working on the same projects.

They often work in cross-functional teams where everyone has input into how the work is done and they all collaborate on delivering features.

But sometimes, it’s hard to live up to this ideal. 

Luckily, lean development has a few tricks on its sleeve to make teams more engaged and involved at all times.

And one of them is, undoubtedly, a practice called Going to the Gemba.

What exactly this means varies depending on the company, but in most cases, it’s some sort of weekly walkthrough or inspection that gives management a chance to check in with developers and see how things are going.

It also helps management stay aware of the developers working on their projects and keep track of how they’re feeling, which can be especially important when it comes to increasing team engagement.

Leaders who take the time to go to the trenches with developers are providing the kind of environment where collaboration and teamwork are encouraged, which eventually leads to more engaged employees. 

Kaizen, or continuous improvement, is one of the core concepts of lean methodology.

The name comes from the Japanese word for “improvement,” and it’s based on the idea that small, incremental changes can make a big difference over time.

However, one thing should be underlined here: the improvements are not aimed at the quality of the product but rather at the quality of development processes.

So how does Kaizen work?

As shown in the picture, you first identify a problem, then analyze processes, create solutions, test them, measure and analyze results, and finally standardize the solution.

One of the most famous examples of kaizen can be found in Google’s search engine algorithm updates. 

Google rolls out new features gradually so they can monitor how users react to them and ensure they provide benefits.

This way, Google can quickly determine what works and what doesn’t, and make improvements accordingly.

If you’re wondering how often you should have kaizen events to have the biggest impact, Radek Pietruszewski, CTO at Nozbe, offers us the answer in the YouTube video below. 

According to him, at Nozbe they meet every week to discuss things that can be improved in the coding process. They notice mistakes, try to find a pattern in them, and look for solutions.

After that, they add a poka-yoke or full proof in order to ensure that making the same mistakes becomes more difficult in the future.

The end-user doesn’t see any changes, and the developers notice only a fraction of them.

But as the improvements add up week after week, kaizen makes the coding process faster, easier, and harder to mess up.

As you can see, kaizen can do wonders for the company’s bottom line. 

It can save time and money through improved efficiency, and fewer errors. 

One of the main principles of lean methodology is to optimize the entire value stream.

In everyday life, we’re often taught to optimize individual parts or processes instead.

For example, if our car is a gas-guzzler, we might try to find a better grade of gas that gives us better performance.

A better approach would be to think about how we can optimize our whole car so that it gets more gas mileage.

The same kind of thinking can be applied to optimizing the value stream in software development.

As shown in the picture, instead of focusing on individual bits and pieces at hand, you should first look at the end-to-end process that delivers value to your users, identify value streams and waste, and optimize the whole stream.

This way you can figure out what’s really working and what’s not working, rather than getting an incomplete picture by examining things in isolation. 

One of the most systematic ways to implement optimization of the entire value stream is to use value stream mapping. 

It’s basically a way of visualizing the entire production flow from beginning to end, with the goal of finding and eliminating waste.

Here’s an example of a basic value stream map.

As you can see, a map shows you all the steps it takes to deliver a product, how long each of those steps will take, and how many steps there are in total.

Seeing all of this information in one place will make it easier to spot bottlenecks or improvement opportunities than simply looking at these things as they happen during normal work days.

As a result, your team will be able to keep moving forward with their work instead of just spinning their wheels and doing the same thing over and over again.

The lean approach to software development has become increasingly popular over the past decade because it aims to reduce the time it takes to get new products on the market.

As companies grow, they can often fall prey to bureaucracy and red tape. 

In response, lean methodology streamlines the system by removing unnecessary steps, getting rid of processes that could potentially slow down work, and approaching products with the assumption that they can improve over time.

In this article, we’ve tried to outline some of the biggest benefits of lean principles. 

Hopefully, you will be able to apply some of them to your own teams and enjoy the advantages that lean software development brings.