Solutions for smarter fab operations

A higher product mix naturally leads to smaller cascades and batches due to fewer lots sharing the same recipe. This creates a constant tradeoff between throughput, cycle time, and batching efficiency. Managing these tradeoffs manually or with rigid rules is unsustainable, especially as the product mix changes week to week.
Flex Local allows fabs to optimize campaign lengths and batch sizes dynamically, based on current WIP and production priorities. Instead of relying on brittle rules (e.g., “wait 5 hours for a batching partner”), Flex Local directly balances cycle time, batching, and changeover costs using KPI-based objectives.

In high mix scenarios, these KPIs often conflict, e.g. longer batching leads to better tool utilization but harms cycle time. Flex Local handles these trade-offs by finding the optimal balance across shifting fab conditions. This reduces the need for constant tuning and ensures efficient outcomes in both high and low mix environments, without relying on static rules.

High mix environments often have complex, uneven recipe enablement across tools. For example, some recipes may only run on one tool while others are enabled across many. Traditional rule-based systems struggle to adapt dynamically to changing tool states or WIP distributions.
Flex Local treats recipe enablement as a native input constraint and dynamically finds the best lot-to-tool assignments. It naturally balances workload and tool availability without relying on static “preferred tool” rules or rigid capacity buckets.

In fact, higher mix reduces the problem size from an optimization standpoint, making it easier to find the best solution within a smaller, more constrained space. Additionally, Flex Local can highlight imbalances in tool qualification by showing which recipes or tools are consistently bottlenecked—giving fab managers actionable insight into long-term improvements.

As product variety increases, so does the number of reticles, along with the complexity of managing their availability. Manually coordinating reticle moves or using simplistic rules (e.g., “only move for hot lots”) leads to delays and inefficiencies.
Flex Local seamlessly integrates reticle availability and location into the scheduling process. It ensures the right reticle is at the right tool at the right time while minimizing unnecessary moves. Rather than creating reticle-specific rules, users simply define the tradeoff between reticle moves and cycle time using general KPIs.

This approach adapts instantly as reticles are added, tools change states, or WIP shifts. No tuning. No rule rework. Just better outcomes with less manual oversight.

In high-mix fabs, small volume products often suffer from unpredictable cycle times and poor on-time delivery (OTD). Legacy systems—whether rule-based or manual—prioritize high runners, leaving low runners neglected.
Flex Local doesn’t prioritize based on product volume. Instead, it schedules all WIP according to holistic KPIs like cycle time and throughput, meaning low runners are treated just as effectively as high-volume products.

This ensures small volume products aren’t at a systemic disadvantage. Fabs can maintain tight delivery schedules and predictable cycle times across the full product portfolio, without needing to define special-case logic for every product variant.

A greater number of recipes per tool increases the need for re-qualification, impacting tool availability. Legacy systems often rely on fixed schedules or static rules that fail to reflect real-time fab conditions, leading to unnecessary delays or underutilized tools.
Flex Local dynamically schedules qualifications based on real-time WIP, tool state, and tradeoffs between cycle time and throughput. Qualifications are not isolated decisions, they’re integrated into the full fab schedule as just another constraint.

This allows Flex Local to find the optimal time to run qualifications, minimizing both delays for lots waiting on qualified tools and idle tool time. It’s a smarter, data-driven approach to managing qualification that scales naturally with fab complexity.

As product mix increases, so do the variables in scheduling. More recipes, more engineering lots, more tool constraints. For rule-based systems, this means either adding thousands of rules (and a large team to manage them) or accepting poor performance. Both are costly and ineffective.
Flex Local thrives in high-mix environments because it doesn’t rely on rigid rules. Instead, it uses constraints and real-time data to generate optimal schedules based on business priorities. Surprisingly, more constraints often reduce complexity for Flex Local by narrowing the solution space.

Where legacy systems buckle under increasing product variation, Flex Local maintains performance, stability, and adaptability, making it the logical solution for modern high-mix fabs aiming to stay competitive without increasing operational overhead.

n legacy fabs, dispatch systems and AMHS often operate with basic dispatching and transport workflows, relying on static rules, limited exception logic, and little integration between dispatch decisions and actual tool or transport system states.

This leads to several recurring problems:

• No awareness of future tool downs: A lot may be sent to a tool that is about to go offline for maintenance, leading to re-queueing or wasted transport effort.
  
  
• No knowledge of upstream arrivals: Dispatchers make tool loading decisions without knowing that a hot hand-carry lot is about to arrive.
  
  
• No visibility of downstream bottlenecks: A lot may be sent to a tool that is already congested or where high-priority WIP is expected to arrive soon.

In all of these cases, the robots themselves do not make intelligent decisions, and the dispatch rules are typically tuned to a specific fab state. Once conditions change, the decisions can easily become suboptimal.

Flex Local improves performance by providing your transport system knowledge about when a lot is required where, and in turn, providing reliable arrival data for the scheduler. This enables:

• Dynamic optimization of transport based on planned tool downs, expected arrivals, and downstream congestion.
• Reduction in reliance on rule-based workarounds such as flags or hard cutoffs.
• Consistent priority-weighted cycle time improvements, even in highly variable fab conditions.

In fabs with complex batching and high WIP variability, batching and changeovers are notoriously difficult to handle with dispatching solutions, even with advanced heuristics. Issues include:

• Missing batching opportunities: A lot is dispatched after waiting 3 hours, just minutes before a second batchable lot arrives—resulting in suboptimal batch size or changeover cost.
  
  
• Transporting to unnecessary queues: A lot is moved by AMHS to a step where it will have to wait, while a lower-priority lot with no queue could have been processed immediately.

These problems are exacerbated in automated fabs, where the hidden dispatcher logic used by experienced operators—such as considering shift hand-downs, arrival times, or current WIP mix—is no longer present.

Flex Local enables transport decisions that are truly optimal and not tuned only to a specific fab state. It does so by:

• Dynamically evaluating batching and queue states based on current and incoming WIP.
  
  
• Considering specific constraints of the transport system, including buffer availability and routing logic.
  
  
• Continuously adapting decisions in real time without requiring manual re-tuning of dispatch rules.

The result is a system that outperforms legacy dispatch in high-mix, high-automation fabs where transport and scheduling decisions must be tightly integrated.

In the photo area, reticles must be stored and retrieved efficiently to avoid disrupting production. However, high-mix fabs can manage thousands of reticles simultaneously, each needing careful allocation into pods and stockers with limited capacity and variable retrieval times. Poor allocation can turn stockers into hidden bottlenecks, delaying wafer processing and reducing throughput.

Traditional approaches often treat reticle allocation as a separate, simplified problem. For example, heuristic solutions have been used to prioritize which reticles are stored in faster-access stocker compartments. While quick to compute and easy to understand, these methods optimize the stocker in isolation, ignoring how decisions affect the broader wafer schedule. This creates a risk of inconsistency and missed optimization opportunities.
By embedding reticle allocation into a global optimization model, Flex Local can solve the problem in full context. Rather than focusing solely on the stocker, all relevant constraints and dependencies are modeled together, including:

• Availability and scheduling of pods for reticle transport
• Transition times between tools and stockers
• Load/unload durations for pods and machines
• Stocker compartment retrieval speeds based on reticle position
• Current reticle and pod locations across the fab

This integrated approach ensures that reticle movements align with wafer needs and tool availability, minimizing idle time and preventing local decisions from creating downstream bottlenecks.
With full-context optimization, fabs gain a consistent, end-to-end schedule that dynamically balances pod usage, stocker capacity, and tool demand. This results in fewer delays, higher reticle utilization, and better alignment with fab KPIs such as throughput and cycle time. Unlike standalone heuristics, this method adapts flexibly to shifting production goals and scale—while optimizing the entire photolithography area, not just one component.

Fabs often operate with specialised toolsets processing wafers with expensive materials including precious metals like gold. These tools represent significant cost centers where material utilisation directly impacts manufacturing economics. The challenge: achieving optimal batch sizes to maximize material efficiency while maintaining acceptable cycle times.

The toolset complexity stems from multiple recipe types requiring different material configurations, varying lot priorities, and dynamic arrival patterns that render static rules ineffective. Engineers may frequently trade off between cost optimization and throughput targets, often requiring manual intervention.

‍

Legacy systems cannot dynamically balance these competing priorities. When material costs are high, engineers want larger batches to amortise setup expenses and maximize consumable usage. However, predetermined minimum batch sizes and wait durations don't adapt to real-time fab conditions, lot mix variations, or changing business priorities.

‍

Flex Local addresses this by dynamically determining optimal batch compositions in real-time. Unlike legacy systems relying on predetermined rules, the optimizer continuously evaluates trade-offs between batching efficiency and cycle time impact based on current fab state.

‍

The system considers material setup costs, lot priorities, recipe compatibility, and dynamic arrival patterns to maximize batch utilization while respecting cycle time objectives. This autonomous decision-making removes manual batch management burden from operators while ensuring consistent batch size optimization aligned with business priorities.

In complex fab environments, even with traditional dispatch systems in place, gaps remain between what’s planned and what actually happens on the floor. Manufacturing specialists often rely on fragmented views, shift notes, or tribal knowledge to determine what to do next. These inconsistencies introduce avoidable delays, missed handoffs, and execution errors that ripple through the fab.

‍

Flex Local’s Runway feature addresses this by converting real-time scheduling and MES data into a unified, sequenced list of upcoming shopfloor actions. Each action card is tied to selected tools and reflects shared priorities, timing, and task details across all users, regardless of role or UI setup.

‍

Because all users are working from the same live data source, supervisors, leads, and manufacturing specialists stay aligned across shifts without manual coordination. This eliminates confusion, reduces rework, and ensures the execution layer remains in sync with the fab’s priorities and current state.

Delays in high-mix fabs often stem from small, compounding mismatches that aren’t easily visible or manageable in real time. A lot may queue at a tool that is momentarily congested, a batching partner may arrive too late, or a reticle may be tied up on a different tool - each causing minor slowdowns that accumulate into significant performance loss.

Flex Local addresses these issues by jointly optimizing tool assignments, batching, and resource movement (i.e. reticles, probe cards, etc.) in a single model. Using real-time WIP, tool states, and fab priorities, the system proactively schedules lots to avoid predictable delays and maintain smooth flow.

Instead of relying on static rules or post-hoc tuning, Flex Local adapts continuously to shifting fab conditions - delivering tighter batches, fewer idle tools, and better resource availability through smarter coordination.

Excessive reticle moves introduce avoidable risk - from physical wear and damage to tracking errors that delay processing. In high-mix environments where reticles are frequently reused and reassigned, these risks are amplified by volume and variability.

‍

Flex Local integrates reticle handling directly into its scheduling logic. It evaluates each move against the cost of reticle transfer, current tool demands, and available alternatives. As a result, the scheduler naturally minimises unnecessary moves while still meeting cycle time and throughput goals.

‍

This built-in awareness of reticle location and movement leads to lower handling risk, more consistent reticle availability, and greater photolithography stability - all managed autonomously.

Multi-chamber tools offer significant parallelism, but in high-mix fabs, it’s common for some chambers to sit idle during runs. Mismatched recipes, lot arrival variability, and inflexible batching rules often lead to partial tool utilization - quietly reducing throughput and efficiency.

Flex Local explicitly accounts for chamber-level configuration and availability during scheduling. When assigning WIP to a tool, it evaluates which chambers can be used for each candidate lot, how incoming lots can be grouped, and how arrival timing will impact run efficiency. The result is WIP selection and sequencing that fills chambers as fully as practicable given the current fab state.

Rather than treating chamber loading as an afterthought, Flex Local builds it into every decision - delivering higher effective utilization, better batching density, and more throughput from the same equipment set.

Timelinks define strict maximum durations between consecutive manufacturing steps to prevent wafer contamination or oxidation. These constraints are especially difficult to manage when they surround bottleneck tools such as diffusion furnaces, where delays or batching inefficiencies can cause significant wafer scrap or costly rework. Heuristic scheduling systems struggle to consistently prevent timelink violations because they lack the ability to reason about future tool availability and upstream/downstream impacts across the full route.
When Flex Global is deployed, timelink constraints are managed explicitly and holistically. The scheduler looks multiple steps ahead, allowing it to shift earlier process steps, such as delaying lots on non-bottleneck tools, to ensure timelinks into constrained tools are met. Rather than focusing on cycle time alone, the scheduler dynamically adjusts dispatching decisions across all toolsets to avoid wafer damage while maintaining a balanced flow.
This method not only prevents costly timelink violations, but also results in more even queue times across the line, reducing bottleneck pressure and improving overall line balance. Whereas heuristics would keep upstream tools constantly loaded—risking downstream violations—optimization introduces strategic idling when needed, yielding superior throughput, reduced wafer loss, and improved adherence to delivery KPIs.

In a complex fab environment, not all timelinks are equally critical. While some violations may result in wafer scrap or major rework, others may only require minor steps like re-cleaning. At the same time, some lots—due to business commitments or chip criticality—carry much higher priority than others. The challenge lies in balancing strict adherence to timelinks with meeting cycle time targets for these high-priority lots. Traditional scheduling systems using heuristics lack the built -in intelligence needed to reason about timelink severity, lot priority, and downstream bottlenecks simultaneously.

‍

With Flex Global, timelinks can be treated with varying levels of criticality. The scheduler first ensures no violations occur on critical constraints, such as those surrounding bottleneck furnaces. For less critical constraints, the system dynamically evaluates whether violating them results in a net gain—for example, accelerating a high-priority lot’s cycle time while accepting minor rework on lower priority wafers. By encoding the trade-off as a weighted cost model, the optimizer can simultaneously improve delivery KPIs and maintain fab stability.

‍

This flexible prioritization allows fabs to reduce cycle time for important lots without sacrificing overall yield or throughput. Critical wafers are protected, while less impactful violations are permitted when strategically beneficial. The result is a schedule aligned with fab-specific business goals—something static rules or heuristics would struggle to achieve. In dynamic bottleneck situations, this approach distributes WIP more evenly, mitigates congestion, and avoids costly over-optimization on constraints that don’t require it.

When bottlenecks emerge unexpectedly, the result is firefighting - delayed lots, strained toolsets, and disrupted delivery schedules. Often, the early signs of trouble are buried in raw data or missed until it's too late to act proactively.

‍

Flex Global includes a dynamic load Heatmap feature that visualizes projected tool utilization across the next 12 hours. By simulating WIP movement through the fab over time, the Heatmap highlights emerging congestion, uneven tool loads, and upcoming slack - giving planners a clear, time-based view of where intervention may be needed.

‍

This visibility allows for earlier, smarter adjustments: slowing WIP releases upstream, accelerating lots to fill idle time, or reassigning tools before queues grow. The Heatmap transforms load balancing from reactive response into proactive management, helping fabs avoid disruption and maintain consistent throughput.

Meeting on-time delivery (OTD) targets in a high-mix fab takes more than long-range planning. As WIP moves from high-level plans into real-time execution, even small delays at individual steps can throw off cycle time - especially in dynamic, constraint-heavy environments.

‍

Flex Global bridges this gap by translating priorities generated by Flex Planner into step-specific scheduling decisions across its 12-hour optimization horizon. It continuously evaluates WIP position, tool state, and fab constraints to adjust timing at the tool-step level - ensuring critical lots stay on track without starving the rest of the line.

‍

This real-time refinement keeps execution aligned with long-range delivery goals, allowing fabs to maintain OTD performance even as local conditions shift. The result: fewer surprises, faster recoveries, and more predictable outcomes across the entire product mix.

A major quality event at a high-mix IDM forces an entire family of lithography tools offline for 12 hours. These tools are critical to a large volume of WIP, and their unavailability risks causing immediate WIP congestion at preceding steps, starvation at downstream toolsets, and prolonged disruption to lot schedules. Traditional dispatching methods struggle to handle such systemic imbalances, reacting too slowly and often making local decisions that worsen the overall fab performance.

‍

Flex Planner responds instantly to the disruption by halting planning of WIP through the affected tools and rebalancing upstream activity to avoid rack congestion. At the same time, it maintains an optimized buffer of WIP that will be ready to move once the tools recover, preventing starvation without overloading any part of the line.

‍

Downstream, Flex Planner identifies alternative lots to keep key toolsets fed. During the 12-hour outage, Etch and Metal Deposition maintain stable throughput with move reductions of under 2%. Over the following day, Flex Planner drives an average 4.25% improvement in utilization at these steps compared to dispatch-only control.

‍

Once the Litho tools return, Planner accelerates recovery of affected lots—returning them to their planned step 38% faster than the dispatching approach, all while maintaining balance across the rest of the fab.

‍

In parallel, the Spotlight feature highlights where further recovery can be gained—recommending tool qualifications and specific actions at Metal Deposition that reduce queue times by 10% during the planning horizon.

‍

This illustrates how Flex Planner goes beyond reactive dispatching to make proactive, global decisions. Even under extreme, unplanned disruption, it maintains flow, protects throughput, and accelerates recovery—by optimizing across all lots, tools, and steps over a 2–4 week horizon.

An advanced‑logic fab running >600 products sees chronic “WIP saw‑toothing”: large surges accumulate ahead of diffusion and lithography at month‑end, followed by starvation mid‑cycle. The pattern is driven by quarterly demand peaks, static weekly release practices, and narrowly focused dispatch rules that view only the next tool. The result is unstable cycle time and constant firefighting to hold queues under control limits.

‍

Conventional planning uses single‑rate capacity tables and spreadsheet models updated once per week. They can show that total move volume fits, but they do not capture the hour‑by‑hour variation in recipe enablement, tool downs, or product mix. Planners therefore release WIP conservatively, creating lulls early in the month and pile‑ups later when hot orders appear.

‍

Flex Planner’s dynamic capacity model updates every 45 minutes, reflecting current tool uptime, qualification status, and operator availability. The optimiser:

‍

• Projects WIP position and queue times for every lot 2–4 weeks ahead.
• Generates hold/release decisions that smooth arrivals to each capacity group, preventing “litho surges” before they form.
• Adjusts planned starts daily, not weekly, so that early‑month slack is filled with lower‑priority lots, preserving headroom for end‑of‑month demand.

‍

Instead of reacting to congestion after it appears, the fab operates with a near‑constant queue profile at diffusion and litho across the full planning horizon. Engineering teams report fewer manual interventions and a marked reduction in day‑to‑day WIP volatility, giving downstream schedulers a far more predictable line to work with.

A foundry services multiple external customers whose contractual scorecard centres on OTD at ship‑lot level. Despite healthy overall capacity, the fab misses delivery windows every week because expedited lots overtake standard products, pushing lower‑margin orders late and triggering penalties.

‍

Manual planners translate customer need‑by dates into a static priority matrix. Dispatch systems then treat every lot in a single class identically, unaware that a standard‑priority die might still be one day from lateness while an expedited die has three days of slack. When unplanned tool downtime shifts the critical path, the priority matrix becomes obsolete until the next weekly re‑plan.

‍

Flex Planner converts each customer due date into a time‑based cost inside its optimisation model. Every 45 minutes it recalculates:

‍

• The slack (time‑to‑due‑date minus estimated cycle time) for every lot.
• Alternative routings or batching options that protect slack on at‑risk orders without starving other products.
• Lot‑level priorities that can be fed directly to existing dispatching systems or to Flex Local for tool‑level scheduling.

‍

Because Flex Planner reasons over the full 2–4 week horizon, it can, for example, deliberately delay a non‑critical clean step today to free furnace capacity three days from now when several high‑risk lots converge.

‍

Delivery performance becomes a controllable output rather than a lagging KPI. Planners shift focus from firefighting to analysing root causes of the few remaining late lots, confident that Flex Planner is continuously steering the rest of the fab toward on‑time shipment.

Wafer starts planning in many fabs is still a manual, spreadsheet‑driven exercise: planners pull weekly demand from ERP, consult static capacity tables, and then negotiate daily start quantities with production. The process can consume two or three engineers for an entire day or longer and the resulting plan is often out‑of‑date before the first shift ends. There are a number of limitations with this manual approach: 

‍

• Static assumptions: Tool downs, qualification runs, and operator constraints that arise after the plan is issued are handled ad‑hoc.
• Coarse granularity: Weekly targets hide day‑to‑day variability in demand and capacity, leading to over‑releases early in the week and rush starts on Friday.
• No feedback loop: Deviations from plan are logged but rarely fed back into the next cycle in a structured way.

‍

Flex Planner utilises dynamic capacity modelling to overcome these limitations and introduce: 

‍

• Continuous capacity sensing: The dynamic model incorporates real‑time tool state and recipe enablement, so available capacity for each product line is recalculated every 45 minutes.
• Start‑lot optimization: The system balances ERP demand, WIP levels, and forecasted bottlenecks to compute the precise mix and quantity of lots to release each day.
• Closed‑loop adjustment: If a critical tool drops or demand shifts, Flex Planner revises the start plan to help keep human effort focused on exceptions.

‍

Starts planning shifts from a labour‑intensive weekly ritual to a background, autonomous process that updates throughout the day. The fab avoids both WIP droughts and surges, maintains better alignment between released lots and downstream capacity, and frees planning engineers to work on higher‑value continuous‑improvement projects rather than spreadsheet maintenance.

Flex Planner’s Spotlight feature autonomously identifies bottlenecks and delivery risks, predicts their future impact, and recommends prioritised actions with quantified benefits. It provides a holistic, predictive view of fab performance and facilitates quicker, more aligned decision-making across teams.

‍

In a typical fab workflow, process engineers manually review lots with either no qualified path or a single path to determine whether additional qualification is needed. However, this traditional method has two major blind spots:

• Hidden bottlenecks with multiple paths: Even when multiple paths are available, one path may still be overloaded due to WIP concentration, creating unseen bottlenecks.
• Lack of foresight: Teams typically only analyse the current WIP state and look one step ahead at most, limiting their ability to take preventive actions.
  
  

These limitations result in reactive, narrowly scoped decisions that often miss early intervention opportunities. Spotlight addresses both challenges with its predictive and holistic capabilities.

• It dynamically analyses all paths, regardless of how many are enabled, identifying actual or forecasted bottlenecks caused by imbalanced WIP flow.
• It uses a 1–4 week predictive horizon to surface qualification opportunities before a path becomes overloaded.
• Recommendations are supported by quantified queue time reduction, giving engineers confidence in the value of the action.

Here is an example: Spotlight detects that a particular lot is expected to queue at a downstream step due to increasing congestion on one of its qualified paths.

‍

Here is an example:

Despite multiple paths being enabled, a bottleneck is forming because most lots are funneled through the same route for this recipe.

To mitigate the risk, Spotlight recommends qualifying an alternate path in advance:

By acting early, the fab avoids queue time buildup, improves cycle time predictability, and prevents delivery risks before they materialize.

Fabs operate under tight resource constraints - limited engineering time, tool availability, and competing production goals. Flex Planner’s Spotlight feature is designed to help teams make the most effective use of their limited resources by prioritising actions based on business impact and operational context.

‍

Spotlight automatically ranks actions according to the severity of the bottleneck, measured by metrics such as forecasted queue time, estimated reduced queue time, or revenue loss. Spotlight enables users to filter their action view based on real-world priorities and constraints, including:

• Product- or shipment-specific prioritization: When a team is under pressure to meet a specific shipment window, Spotlight allows users to filter and prioritize actions related to key products or shipment weeks. This helps teams make trade-offs, such as temporarily sacrificing line balance to ensure on-time delivery for high-priority lots.
• Area or layer-specific focus: Engineers and area managers can filter actions by specific workstops, process layers, or fab areas, helping them focus only on what’s most relevant to their domain of responsibility. This is especially useful for allocating constrained engineering effort where it matters most.
  
  

By surfacing only the most impactful and feasible actions based on fab constraints, Spotlight reduces the noise and cognitive load on teams. It provides a clear, ranked to-do list aligned with business goals and operational bottlenecks.

In a fast-paced fab environment, teams are often forced to act without full visibility into the trade-offs or effectiveness of their decisions. Flex Planner’s Spotlight feature addresses this challenge by providing quantitative insight into the impact of each recommended action—before it's executed.

For every recommended action, Spotlight runs two simulations:

1. Baseline scenario: The fab’s projected performance without taking the action
2. Action scenario: The projected performance assuming the action is taken

By comparing the two, Spotlight estimates key improvements such as:

• Queue time reduction at the bottlenecked step
• Impact on delivery performance or cost index

This simulation-driven approach allows fab teams to see the benefits before committing time or resources. Rather than relying on intuition, tribal knowledge, or trial-and-error, teams get a clear, data-backed estimate of the return on each action. This empowers them to: prioritise actions that deliver the greatest measurable benefit, and avoid low-impact efforts that drain resources.

Beyond technical benefits like reduced queue time or improved cycle time, Flex Planner’s Spotlight feature enables fabs to understand the monetary impact of each recommended action. This allows engineering decisions to be evaluated not just by feasibility or urgency—but by financial return.

For each recommendation, Spotlight performs a background calculation of net value in dollars ($), based on two components:

• Gain - avoided penalty costs: By reducing queue time, more lots meet their delivery targets. For customer-linked delays, actions that prevent lateness directly reduce contractual penalties or missed revenue
• Cost - cost of recovering a tool (e.g. purchasing or repairing parts)

To ensure the accuracy, Spotlight can source the data either from fab internal database or user provided insights. By surfacing the dollar-value gain of each action, Spotlight empowers fab teams to focus resources where ROI is highest and justify engineering actions to management in business terms.