Single Piece Flow
A single piece flow is one of the fundamental approaches to Lean Manufacturing. This concept allows you to process one piece at a time and allow it to flow between different processes.
One-Piece Flow can also be known by other names, such as:
- One-piece Flow
- Make-one, Move-one
- Single-piece Flow
- Continuous Flow
- Flow Manufacturing
This is in contrast to batch processing where pieces are accumulated prior to the whole group moving on to the next operation. This results in a significant reduction of work in progress (WIP).
You will need a single piece flow
- Kanban, or pull system
- Consistent processing times that meet takt time requirements
- Equipment reliability and uptime
- High efficiency and low changeover time consistent with SMED (single-minute exchange of dies).
- High-quality products are essential
TPS stresses the importance of correctly sizing batches. Queues can lead to waiting times which in turn leads to poor space and resource utilization.
The Batch-and-Queue method, on the other hand, teaches us how to build stuff and then let it wait for the next step. The poor utilization of space due to the large number of work orders that are waiting to be completed, the longer cycle times, and a higher likelihood of defects, as well as lower morale. Batch-andQueue creates a lot of work-in-process, not finished goods, which further burdens the team with the thought that “man, there is so much more to do.”
One-Piece and Other Processes
Single Piece Flow is applicable to many other processes. Here are some examples:
- Software: Most software can be built modularly, that is, in smaller modules where one class can use or consume the services of another module. Modular code should be small enough that an engineer can complete each module including any dependent modules. This avoids the need to build multiple modules simultaneously, which leads to task-switching and waste.
- Software Requirements: Requirements documents have been traditionally chubby and patchy. A one-piece flow approach to software development is to use the Agile method. This involves creating user stories, prioritizing and prioritizing each story, then unpacking each story into atomic units called “tasks”, with time attached. Each task represents continuous flow in software development and is a take-one-put-one approach. Joel (Joelprah), talks about task-switching in software development and simulates the detrimental effect it has on productivity. One-piece flow embraces iterative development and rejects the Waterfall approach which is akin at best to Batch-and-Queue.
- Amazon made it mandatory that an order be fulfilled at once. This concept was difficult to grasp by the associates until we explained that batch-and-queue leads to “switcheroos”, which is the mistaken placing of an item in the incorrect order. This defect was avoided entirely by using the one-piece flow method. It also allowed for shorter cycle times which enabled the order to be shipped on time.
You can use the Single Piece Flow principle in many other ways. Before you use Single-Piece Flow, here are some things to remember:
- The process must be capable of producing consistently high-quality products. One-piece flow is difficult to implement if there are quality problems that are consistent and serious.
- The process must be repeatable.
- Equipment should have an uptime of at least 100%. Otherwise, interruptions can disrupt the flow.