assembly chain or assembly line is an architecture that is pretty much the same as a simple chain: there is the trunk of the process — the main sequence of steps, and there are branches, the tributary chains that supply certain ingredients/parts to the main process.
Examples: manufacturing line, supply chain, construction of a house, and a project with parts of work executed by different people.
Research landscape of the Assembly chain
There we need to explore three spaces: the architecture of the assembly process and supplies (the trunk and incoming branches), the architecture of a product being assembled, and in some cases, the tools that are used to execute separate steps of the process, especially when these tools are expensive and one tool is utilized in several operations.
The same as with the simple chain, the understanding of ingredients is very important. Some of these ingredients are most critical or expensive. They are being supplied to the main process through a tributary chain, so these critical supplies deserve your detailed attention and deep exploration.
Examples: engines are critical for vehicle manufacturing, ink for printing services, and medicine for hospitals.
Steps of the process
When designing or improving the assembly process, you obviously need a map of the trunk and the branches. More than that, optimized assembly requires synchronization of deliveries and the storing of parts and unfinished work in progress. When a critical supply does not come on time, the entire chain gets put on hold because the process can not move forward without this critical ingredient or finished work.
Examples: shortage of chips in electronics manufacturing, project delays caused by bureaucratic procedures, and late delivery of design creatives during an advertising campaign.
The synchronization of expensive tools/resources that are used to execute the individual steps of the process. When the same tool or resource can be used in different steps of processes, it is important to schedule its work with the understanding of the general priorities, delays, and availability.
Examples: shared usage of the same machine tool for processing of different parts in the manufacturing process, a designer preparing visuals for two different projects, and the same meeting room scheduled to be used by several teams at once for brainstorming sessions.
The same way as the simple chain, the assembly process has its bottlenecks that reduce its performance. However a multi-branch architecture gives us new degrees of problem space. In such a process we may replace not just one step, but the entire branch.
For example, if the main trunk process expects a certain component coming from a tributary chain, we may reengineer or replace this whole secondary chain without changing the trunk process. We just need to receive supplies of the same quantity and quality from an alternative source.
We can change the supply procedures entirely, or make Build or Buydecisions: develop our own new chain of the component creation or find a third-party vendor who can sell us an off-the-shelf component.
The drawback of this flexibility is the potential shortage of the critical supplies due to external factors and fluctuations. In a simple chain, we were assuming that we either have the right ingredient or not, so we have to use an alternative one. In a more complex assembly chain we are in a situation of “the component is scheduled for delivery”. The bottleneck in the secondary supply chain becomes a bottleneck in the main trunk process. So the solutions may be different: resolve the bottleneck in the secondary chain, find different suppliers, use an alternative component with not exactly similar properties, increase inventories for this type of components, develop just-in-time procedures and so on.
As for tool availability and scheduling issues, it’s always important to understand if a particular tool or a resource becomes a bottleneck. These critical shared tools may cause serious underperformance of the chain. Solutions may vary: improved scheduling procedures, dedicated tools instead of shared, using simpler and less expensive tools for different processes instead of sharing an expensive and universal tool, reengineering of one of two conflicting processes so it does not require this tool anymore, and others.
In such architectures, it is even more important to optimize the overall performance of the chains instead of over-optimizing one separate piece. The advantage is however that a clever reorganization of the chain and elimination of several bottlenecks can give huge throughput improvement(50%, 100%, 200%) even without major investment, by using existing tools and resources in a more intelligent way.
Common illnesses of separate nodes and the whole assembly chain:
- Low throughput
- Expensive processing or ingredients
- Low tolerance to the ingredient variation
- High failure/defect/waste rate
- Delays in supply of the critical components
- Poor availability, condition or conflicts in usage of tools required to execute the step
- Inventory shortages or overstocking
- Expensive idle time
- Too much unfinished work in progress
Leveling guide — Assembly chain
If you’re designing and building a process from scratch:
Create Placeholders of all steps of the trunk process. Try to avoid owning the supply branches (start with buying components instead of building).
Upgrade all steps of the trunk process to the Quick & Dirty level (Low Fidelity, Medium Quality). Populate several tributary branches with Placeholders.
Upgrade the tributary branches to the Quick & Dirty level.
If you’re improving an existing process, skip the phases 1 through 3 and go to the next phase:
Target discovery: identify the main bottlenecks and understand the nature of their illnesses: bad process, critical supply, critical shared tool, poor scheduling and coordination, ingredients variability, etc.
Understand if improvements may be done without building anything new, but with reorganizing and realigning the existing elements, prototype a Quick & Dirty version of an alternative architecture and test it, find out if the performance is sensitive enough to such changes and if these experiments are feasible. Sometimes structural changes are too expensive and should be left for later phases.
Explore the potential improvements of the individual nodes: create several experimental Quick & Dirty (Medium Fidelity — Low Quality)alternatives.
Once you proved one of these prototypes has potential, upgrade it to a Good Enough (Medium Fidelity — Medium/High Quality) level, pick another alternative if this effort did not work out.
Don’t overinvest and don’t try to create State of the Art (High Fidelity-High Quality) solutions for the main bottlenecks of the chain. Start experimenting with State of the Art solutions only when all main nodes are already at the Good Enough level and the structural changes do not bring a significant improvement.
Always evaluate not just the improvement of individual nodes, but also the performance change of the chain as a whole.