Theory Of Constraints And Software Engineering (Improving the throughput)

About one year ago or so I was introduced to the Theory Of Constraints (TOC). It was one of the best things that have ever happened to me as a manager. It changed my view on everything,  It was all thanks to one of my colleagues coming back from a conference and ordering in a book called the "Phoenix Project", the only reason why I was excited about reading it was because of its funky cover (Figure 1).

Figure 1. Phoenix Project Book Cover

As soon as I started to read this book I was instantly hooked, I didn't know at the time that I was going to discover something very important.

In this article I will briefly talk about my understanding of TOC and how I have applied it at work.

Right, let's jump in.

Imagine for a second the following situation. You are an owner of a digital agency, your agency builds web applications only for e-commerce/marketing companies. The following disciplines work for your agency: 10 business analysts, 7 designers,  10 testers, 15 software engineers and 2 web developers. Due to type of work that this agency does (front-end heavy) it should be obvious to us that our constraint in this case will be our web developers. This means no matter how hard other disciplines will work the only work that will be actually shipped to our clients will be what web developers had time to work on. All other work that was done independently by other disciplines will be stored away, waiting for web developers to catch up. This means that your overall throughput is completely constrained by your web developers. 

Let's resolve above situation by using "TOC 5 Focusing Steps" (5FS):

1. Identify - Find your constraint (you can use Kanban, Utilisation charts, etc), in our case web development is our constraint.
2. Exploit - Now we need to find out exactly what process this discipline is following, what is making this disciplines life painful, is it a build server? Is IDE not working correctly? Are web developers too involved in the backend development and backend developers should be doing more? In other words offer all the help that you possibly can. Make sure that web developers have always some work to do, after all they are the constraint. 
3. Subordinate - Make it all about your constraint, only do as much work as a constraint can handle and avoid at all cost the pile up of inventory, this means that disciplines before and after the constraint will be idle. This is not a problem, there will be a much bigger problem if these people are not idle! Now you will need to start to set work in progress limits with buffers, in TOC world it's known as "Drum-Buffer-Rope". 
4. Elevate - Hire more people in, change the process, transfer some of the existing staff in to the constrained discipline, do what ever you can to break this constraint.
5. Repeat - By now your constraint should have been broken, so you need to find your next constraint. Don't allow inertia to become a system constraint. 

This video does a great job demonstrating TOC. TOC also focuses on inventory and throughput accounting, I am not going to talk about throughput accounting but I am going to talk about inventory.

Inventory in software engineering is the following:

• Work In Progress (anything that is being developed in the current iteration)
• Unassembled or partially assembled work (POCs, Shelved code, Designs, Wireframes, Business requirements, etc)
• Backlog items / Requirements / Bugs

Figure 2. Lots Of Inventory = Lots Of Waste

This is what happens when you have lots of inventory in the system:

1. What was produced is no longer needed.
2. What was produced was wrong.
3. Need to juggle lots of work at the same  time (context switching / multi-tasking).
4. What was produced needs to be relearnt again.
5. It becomes extremely hard to keep track of versions, projects and roadmaps. More processes and bureaucracy will be added to keep everything under "control".

As inventory builds up, waste builds up and it compounds the problem.

One of the ways to remove inventory build up is by cutting out "hand-shake / handover" periods between different disciplines. For this to happen teams need to work together as one unit delivering shippable software every iteration. In the Agile world these teams are also known as feature teams (multidisciplinary teams) they produce inventory just-in-time.

After reading lots about TOC I as a Product Owner have decided to give it a try with one of my feature teams at work.

Here is how we have applied TOC and some other good practices:

• We have acknowledged testers as our constraint, these guys had to do manual and automation testing (Identify).
• We have helped them by identifying what problems they were facing most often, in our case it was a build server was taking too long to build and to publish the latest application (Exploit).
• We have knowingly created a bit of inventory for the next iteration each time, this way testing had something to work on straight away as soon as iteration started, this ensured that they are busy at all times (Exploit).
• To deliver to testing team faster we have broken our requirements down, this ensured continuous flow (Exploit).
• Testing was in the loop at all times so there were no surprises with requirements (Communication).
• We never undertook any work that was vague or unknown (Risk reduction).
• If we couldn't estimate work or write down a good acceptance criteria for it (because it was unknown) we would create a time boxed investigation task (Risk reduction).
• If there was a quality issue or something unknown came up during development, team would stop the line and get an answer immediately (Communication).
• Certain type of work would be done in different parts of iteration, for example at the end of iteration testers would be regression testing, this was an ideal time for other disciplines to do some infrastructure work or training (Subordinate).
• We did only as much work as testing team could handle (Subordinate).
• We were looking to hire more testers (Elevate).

Figure 3. Stop The Line.

Above steps have really helped us to improve our throughput, but it also did way more than that. This team was:

• One of the most efficient teams in the department.
• Everyone always left on time / no one ever had to do overtime.
• They have finished ahead of the schedule at worst they have finished on time.
• As they have finished ahead or on time they had time to groom requirements and get ready for the next iteration (maybe even start work ahead of the schedule).
• Team has gelled incredibly.

Of course none of this would not have been possible if I didn't have incredible people in the team, their personalities have played the key role.

Summary: 

• Stop doing work upfront per discipline (creating inventory) and star to work together as one multi-disciplined team (feature team) by using continuous flow / just-in-time delivery.
• Have your team deliver production ready software every iteration.
• Break down your requirements in to small deliverables (continuous flow) to achieve full multi-disciplined team utilisation. 
• Use Kanban board / Utilisation charts to visualise your constraints. 
• Use TOC 5FS to increase your teams throughput.
• Ensure that your constraint is never starved of work and is protected from distraction, inefficient processes and bureaucracy. 

Useful links:

• TOC using Agile Wall (Video)
• Single Piece Flow (Article) 
• Goldratt - Drum-Buffer-Rope (Article)
• What is Drum-Buffer-Rope (Video) 
• Pass the pennies game - Single Piece Flow (Presentation) 
• TOC with Throughput Accounting (Article)
• Stop The Line - Andon Dashboard For Software Engineering Teams (App)