PlateUp! Automation Guide for 1.5: Build Lines That Recover

A PlateUp! automation is finished only when it returns to a stable starting state. Producing one plated meal is a demonstration; producing the next meal while the first dirty plate travels back to washing is a system. Build that closed loop in modules so a wrong item, blocked output, or patch change has one place to investigate.

Current-version boundary: the cutoff here is the August 11, 2026 PC release labelled 1.5.2-7473. The 2026 update line changed sink automation from Combiner to Portioner, improved Smart Grabber priority, fixed transfers between grabbers, and expanded what Portioners and Combiners can do. A layout from an older video may have correct geometry but an obsolete interaction.

Draw one item transaction before placing belts#

Choose one customer order and write every state it must occupy. A simple line might read:

raw ingredient -> prepared ingredient -> cooked item -> plated meal -> customer -> dirty plate -> washed plate -> plating point

Mark the appliance responsible for each arrow. A Grabber moves an item. A Mixer processes it. A Hob cooks it. A Combiner joins two compatible items. A Portioner removes one serving or interacts with certain providers. An Auto Plater applies a plate. If an arrow has no appliance, the player owns that handoff. If two appliances own the same handoff, they may race or block one another.

Do not start with the final screenshot. Start with one source, one processor, one safe output, and enough open floor to observe it. The target is not “full automation.” The target is “this item always reaches this buffer in the correct state.”

Understand what a transport tile is actually doing#

A Conveyor carries an item placed on it toward its arrow. A Grabber adds a pull from the tile behind it, then pushes the item toward its output. It handles one item at a time and waits for many automatic processes to finish before pulling. This is why a line can appear idle while a Hob, Soaking Sink, or Portioner is still working.

A Smart Grabber adds a filter. Train it in Practice Mode by placing the exact desired item on the belt; verify the item icon above its camera. An untrained Smart Grabber learns from the first item it receives, which can silently turn a dirty-plate branch into a clean-plate filter or teach a food line the raw form instead of the cooked form.

A Rotating Grabber can change its output among left, forward, and right during service. Use it as a deliberate switch or shutoff, not as an unlabelled junction that a player must remember under pressure. Set and test the direction during Practice Mode, where it will carry into service.

At every transfer, leave a legal destination. A belt that is ready to push into a full counter remains occupied; the upstream Grabber then cannot release its item, and the blockage travels backward. One empty buffer tile between modules makes the failure visible and gives the player a safe rescue point.

Prove source, process, and exit as three separate tests#

Build any production module in this order:

1. Source test: confirm the provider releases the intended raw item to the first transport.
2. Process test: place that item manually on the processor and verify the resulting state.
3. Exit test: start with a completed item on the processor and confirm the output clears before burning, over-processing, or colliding.
4. Joined test: connect the three parts and run several items, not just one.

Practice Mode cats are useful for serving geometry, but only one group appears at a time. Practice can prove item correctness, Smart Grabber training, customer adjacency, and dish return. It cannot prove that the line has enough peak throughput for the expected groups and rush cards shown for the day.

Choose the mixer by what must happen after processing#

The base Mixer chops or kneads automatically but is slower than fast manual work. Its upgrades solve different constraints:

• Rapid Mixer: use when processing speed is the limit and another appliance owns transport and cooking.
• Heated Mixer: use when one compact tile should process and cook without burning. It saves space and components, but its cooking is slow and it prefers processing before cooking.
• Conveyor Mixer: use when the completed processed item must leave automatically. It pushes forward after processing but does not combine ingredients by itself.

A Heated Mixer is not always the efficient choice. If the recipe must be produced quickly, a Rapid Mixer feeding a safe cooker can have greater throughput. If floor area is the true limit, the slower compact module may be better. Measure which state waits: raw inputs piling before the mixer means processing is late; processed inputs piling before the Hob means cooking is late.

When a Conveyor Mixer pushes into another appliance, test an item it cannot process as well. The mixer may still transport that item, which can be useful for pass-through behavior or can send an unexpected object into the next module.

Keep cooking speed and burn safety as different decisions#

A Danger Hob is fast but converts an output delay into a fire. A Safety Hob is slower but holds completed food safely. An Oven or Microwave encloses the item and needs a control action; a Microwave uses a fixed operation and can create fire when misused. Match the cooker to the reliability of its exit.

Use a fast Hob only after the next tile has demonstrated spare capacity. A Grabber will generally wait for cooking to finish before pulling, but its output must also be clear. If plating, combining, or the next belt can stall, the Hob is not isolated from that downstream problem.

A Combiner can create a safe endpoint for certain foods. With a bun in the Combiner aimed at a cooked burger patty, the pieces join when the patty is ready; the completed burger no longer continues cooking like the bare patty. This removes one burn window, but only if the bun supply and Combiner orientation are reliable. Test the missing-bun case deliberately so the cook knows what the line does when the provider is blocked.

Use Combiners for joins and Portioners for extraction#

A Combiner carries one item and applies it to the compatible item in front of its arrow. It can add a bun, join an ingredient, or act as a plate applicator when a plate is held on it. In 1.5, Combiners can also bin compatible waste. They should face the destination object, not the source that supplied the carried item.

A Portioner faces the batch, pot, provider, or other source it will extract from. It brings the portion onto itself and can combine that portion with a compatible item already occupying the Portioner. That makes it useful for pizza, turkey, soups, bread, sides, and other multi-serving dishes, but the depleted object still needs a route. A pot, bone, tray, or drained remainder can block the next batch even when the portions moved correctly.

The current sink rule is easy to misremember. Sinks, Milk Dispensers, and Ice Dispensers no longer fill items merely because a Combiner points at them. Use a Portioner for those provider interactions. In the current line, a Portioner aimed at a basic sink can add water to a compatible item placed on the Portioner. If an old layout stops at an empty pot or dough state, replace the obsolete fill handoff before rebuilding the rest.

Version 1.5 also lets Portioners take from item providers and empty full bins automatically. These abilities can close loops that previously needed a player, but they do not decide where the emptied waste or new item should go. Preserve an exit and a capacity check.

Plate after the food reaches a stable state#

Plating too early can make a food impossible to process further; plating too late can leave a cooked item burning or waiting. Put the plating point immediately after the final required cook, portion, or combine step.

There are three useful patterns:

• Auto Plater beside completed food: it supplies plates to the item when the geometry is valid.
• Combiner holding plates: point it at the stable cooked output and let it apply the plate.
• Plate buffer plus Smart Grabber: filter clean plates before they enter the final assembly tile.

Count the plates already committed to tables, return lines, sinks, and conveyor tiles. A rack that looks full during preparation can be empty in service because the whole set is travelling. If production pauses only after several groups have eaten, the problem may be plate circulation rather than the food module.

Serve across a fixed edge and preserve customer access#

Customers can take required items from a Conveyor, Grabber, or Teleporter adjacent to their table. The table still needs suitable active chairs and a customer route from the front door. A technically adjacent serving belt can make a chair unreachable or merge table sets into a different capacity.

Test each table with the largest possible group for the day. Confirm:

1. the group sits in the expected chairs;
2. the order can be taken through the chosen method;
3. every required dish or course reaches a customer-accessible tile;
4. the dirty plate appears where the return module expects it;
5. the table becomes clear for the next group.

An Ordering Terminal removes the walk to each table but reduces the service-phase patience available for taking orders. It does not fix a slow kitchen, hidden order, blocked delivery, or missing course. Place it where it removes a proven waiter route, and stop pressing it when the kitchen cannot absorb another order.

Teleporters can cross rooms without a conveyor chain, but they require a paired plan and usually several days of discounting and copying. Use them for a boundary that is genuinely expensive to cross, such as kitchen-to-dining delivery or remote dirty return. The research guide covers the blueprint pipeline for a matched pair.

Design dish return as its own factory#

Dirty plates are not a cleanup detail. They are the input to the next meal. Start the return module at the table or service edge and trace it backward to the clean-plate buffer.

Sink upgrades solve different jobs:

• Power Sink: accelerates player-operated washing.
• Wash Basin: accepts a batch but still needs an operator; current updates preserve partial progress more reliably.
• Dish Washer: runs a closed batch cycle and needs loading, activation, and unloading in the surrounding design.
• Soaking Sink: washes one plate unattended, making it suitable for a steady automatic stream rather than a sudden pile.

Feed only dirty plates into the washing appliance. A Smart Grabber at a mixed bus line should be trained on the dirty state in Practice Mode. Recent patches fixed cases where Smart Grabbers failed while pulling from other grabbers, but the filter still needs an example that matches the arriving item.

Provide a clear clean-output tile and a route back to plating. When plates remain in the sink, ask whether washing is unfinished, the clean exit is full, or the Grabber is trained incorrectly. When dirty plates pile at tables, ask whether customers can release them into the return edge and whether the first transport is free.

Branch only at a state you can identify#

A branch is safe when its items are visibly different. Raw and cooked food, clean and dirty plates, full and empty pots, or two distinct toppings can be separated by trained Smart Grabbers. Two identical items intended for different customers cannot be routed by item filter alone.

For a two-output junction:

1. place a buffer before the branch;
2. train each Smart Grabber with the exact state it should pull;
3. leave a default path or an explicit stop for anything unmatched;
4. block one output in Practice Mode and observe whether the other remains safe;
5. retrain after moving or replacing a Smart Grabber.

Use a Rotating Grabber when the choice is made by the player rather than by item identity. Label its normal direction through layout or floor color, and set it before the rush. A manual switch in the middle of a cooker exit is a hazard unless the closed direction leads to a buffer.

Measure throughput at the slowest completed cycle#

A long belt can make movement look productive while the same cooker or sink limits every meal. Time the module from raw input entering to the output tile becoming available for the next item. Then compare that cycle with the arrival pattern and number of portions per batch.

Use inventory accumulation as the meter:

• raw items accumulate before processing: increase processing capacity or remove a transport wait;
• processed items accumulate before cooking: the cooker is late;
• cooked items accumulate before plating: plate supply or final assembly is late;
• plated meals accumulate before tables: ordering, serving access, or table turnover is late;
• dirty plates accumulate after tables: return or washing is late;
• nothing accumulates but orders wait: the whole line lacks capacity or starts too late.

Add capacity at the accumulation point. Duplicating every appliance doubles cost and space without proving which stage needed help.

Stage the rollout across safe days#

Build automation in a sequence that always leaves a manual recovery path:

1. stabilize manual cooking and table service;
2. automate one preparation or portioning step;
3. add a safe cooker exit and plate application;
4. deliver to one test table;
5. create a dirty return for that table;
6. close the clean-plate loop;
7. copy the proven module or extend it to the remaining tables.

After each stage, move one appliance out of service and confirm the player can still rescue the day. If no recovery tile or handoff exists, the design is too tightly packed to debug.

For a first clear, use the Day 15 guide to decide whether automation is actually the next bottleneck. Several PlateUp! achievements use tiny conveyor, fire, or no-movement setups; stage those separately instead of deforming a productive overtime restaurant.

Read failures as local evidence#

• Grabber never pulls: inspect input direction, unfinished processing, blocked output, and Smart Grabber training.
• Wrong item enters a branch: retrain with the exact state and verify no unfiltered path can steal it first.
• Food burns after working once: downstream capacity is lower than the cooker rate or a required combining item ran out.
• Pot or tray blocks the line: route the depleted container, not just the portions.
• Sink no longer fills a recipe item: replace the pre-2026 Combiner interaction with the current Portioner method.
• Table will not accept food: verify customer seating, item completeness, adjacency, and whether another course is active.
• Clean plates vanish from circulation: count every table, belt, sink, and staging slot before buying more.

When the geometry is correct but an interaction changed after an update, reduce the module to one source and one destination. Version 1.5.2 is the boundary for this guide; a future patch note should override a historical workaround.

Sources and build notes#

Game identity and the untouched automation screenshot come from the official PlateUp! Steam listing. Transport actions, appliance upgrade families, processing behavior, table adjacency, and dishwashing roles were checked against the supplied PlateUp! Wiki appliance pages. The developer’s Turning Up The Heat changelog and the April-August 2026 Steam sequence define the newer sink, Smart Grabber, Portioner, Combiner, blueprint-copy, and transfer rules. Older automation guides remained in the ledger as limited or blocked references and were not treated as current layout guarantees.