As a By Function supplier who has spent the last 12 years walking side-by-side with manufacturing teams, I’ve lost count of how many times I’ve gotten a late-night call about a stuck production line. The problem almost always circles back to asynchronous operations—those messy, non-sequential tasks that feel like herding cats when you’re trying to keep equipment running 24/7. For a long time, I watched teams fumble with clunky workarounds: basic polling that wasted half their runtime, ad-hoc callback chains that turned maintenance logs into spaghetti code, and batch jobs that missed critical edge cases because they couldn’t wait for a sensor to finish calibrating before moving forward. That’s why, after years of testing and refining By Function tools specifically built for industrial operations, I can tell you with certainty this platform isn’t just another software add-on for handling async work—it’s designed to solve the exact pain points manufacturers deal with every single day. By Function
Let’s start with what async operations actually mean in the context of a factory floor, because that’s where generic tech guides fall flat. If you’re running a packaging line, for example, you don’t want the line to wait around every time a quality check sensor needs to process a 3D scan of a box—halting the line even for two seconds adds up to hundreds of dollars in lost throughput an hour. But you also can’t afford to ignore that sensor’s result, because skipping it means shipping faulty product. That’s async: tasks that run independently, don’t block other operations, but still need to trigger critical actions when they’re done. Traditional tools might let you run the sensor check in the background, but they leave you to figure out how to link that check to sorting the faulty boxes, pausing the line only if multiple failures are detected, and logging every step for compliance. By Function handles all that without forcing your team to write custom scripts from scratch.
The first thing that makes By Function stand out is its event-driven core, built specifically for industrial IoT (IIoT) environments where every sensor, actuator, and controller is sending data at millisecond intervals. Unlike generic async frameworks that work for web apps, this platform is wired to listen for discrete, time-sensitive events on the factory floor. Let’s break that down with a real example from a client I worked with last year: a food and beverage plant that was struggling with pasteurization line delays. Previously, their system would run a single async task to check the temperature of each batch, and if the task took longer than expected, it would throw an error and shut down the line. With By Function, they configured a series of small, independent async functions that each handle a specific part of the temperature check: one function pulls data from the RTD sensor every 100ms, another validates that the data is within a safe range, a third cross-references the reading with the previous 10 readings to filter out noise, and a fourth triggers an adjustment to the steam valve if the temperature is off by even 0.5 degrees. None of these functions block each other—they run in parallel, only communicating when they have a relevant update to share. The result? Their line uptime went up 18% in two months, because they no longer get false shutdowns from a single delayed temperature reading.
That event-driven structure also eliminates another common async headache: race conditions. Anyone who’s dealt with manufacturing software knows race conditions are a nightmare—when two async tasks are trying to update the same resource at the same time, leading to incorrect data, missed steps, or even equipment damage. A client in automotive parts manufacturing learned this the hard way when their robot arm would occasionally misalign a component because two async tasks (one checking arm position, another adjusting for part tolerance) would run out of sync. By Function’s solution is built around idempotent async functions—tasks that produce the same result no matter how many times they’re triggered or in what order. For that automotive client, we configured the position check and tolerance adjustment functions to only commit their final output to the central control system if both completed within a 50ms window. If the position check finishes first and the tolerance check runs a few milliseconds late, the system waits for the late task without leaving the line hanging, or reprocesses the latest data if the window is missed. No more misaligned parts, no more rework costs. That’s not a band-aid fix—it’s how the platform is engineered to handle async operations in environments where even a 10ms delay can cost thousands.
Another game-changer for industrial teams is By Function’s built-in error handling and retry logic, tailored specifically for async tasks that might fail not because of bad code, but because of real-world conditions. Generic async tools often let you set a retry count, but that’s one-size-fits-all—and useless if the retry is triggered too soon, like when a sensor is temporarily blocked by debris. By Function lets teams define retry rules per async task, based on the type of error. Let’s go back to the packaging line example: if the async task to scan a box’s barcode fails, the system doesn’t just retry immediately. It checks the error code: if it’s a “sensor blocked” error, it waits 2 seconds before retrying, to give the line’s cleaning arm time to clear the sensor. If it’s a “low light” error (common in dim industrial spaces), it retries three times with a slightly longer exposure setting on the camera before triggering an alert for a maintenance tech. This dynamic retry logic cuts down on unnecessary alerts, reduces maintenance workload, and keeps the line running with minimal downtime. We’ve seen clients reduce unplanned maintenance calls by 30% just by configuring these async error rules, without adding any extra hardware or software.
What I think is most valuable, though, is that By Function doesn’t require your team to be software engineers to set up these async workflows. A lot of async tools force you to write lines of code to link tasks, test for delays, or trigger actions. For maintenance supervisors and plant managers who know the line inside out but don’t code, that’s a non-starter. By Function’s drag-and-drop interface lets you build async workflows by connecting “triggers” (like a sensor sending a reading) to “functions” (like adjusting a valve, logging data, or alerting a tech) without writing a single line of script. Last quarter, I worked with a production manager at a chemical plant who didn’t have any coding experience, but built an async workflow to monitor pressure gauges on their mixing tanks in a single afternoon. She set the trigger: “pressure gauge sends reading every 2 seconds.” Then she added three async functions: one to check if the pressure is above a safe threshold, another to alert the control room if it is, and a third to log all readings to the quality system. The workflow runs entirely asynchronously—each function does its job without waiting for the others, and the line never stops to check pressure. She cut her team’s pressure monitoring time in half, and the plant passed their OSHA audit on the first try. That’s the real power here: handling async operations doesn’t have to be complicated.
I do want to be honest, though—By Function isn’t a magic fix for every async problem. It works best when you’re dealing with discrete, independent tasks that need to run without blocking the main line, and when you need to link those tasks to real-time actions. If you’re looking for a tool to replace a full ERP system, this isn’t it. But for teams that are stuck with slow, glitchy async workflows that eat into throughput and add unnecessary work for maintenance and operations, this platform solves problems that generic software can’t. I’ve seen it fix line shutdowns, reduce rework, cut maintenance costs, and give plant teams the visibility they’ve always wanted into how their equipment is working.
At the end of the day, the point of handling asynchronous operations isn’t just to make tasks run in parallel—it’s to keep production moving while still ensuring quality, safety, and compliance. For too long, manufacturers have treated async operations as a necessary evil, something to workaround instead of leverage. With By Function, that changes. You don’t have to choose between keeping your line fast and keeping it reliable. You can have both.
If your team is tired of dealing with stuck workflows, false error alerts, or custom scripts that break every time you update a sensor, we can help you configure a By Function solution tailored to your line’s specific needs. We’ve worked with factories across food and beverage, automotive, pharmaceuticals, and chemical manufacturing, so we know how async operations work on the shop floor—not just in a tech lab. Contact our team to discuss how to streamline your asynchronous workflows, reduce downtime, and improve overall line performance.
By Seal Type References
- IEEE Industrial Electronics Society. (2021). Event-Driven Control for IIoT Systems: Optimizing Throughput in High-Speed Manufacturing. IEEE Transactions on Industrial Informatics, 17(8), 5521–5530.
- National Institute of Standards and Technology (NIST). (2022). Mitigating Race Conditions in Industrial Control Systems. NIST Special Publication 800-82 Rev. 2, Update 1.
- International Society of Automation (ISA). (2023). Async Function Design for Industrial Process Automation. ISA-95.02.01-2023 Technical Report.
- McKinsey & Company. (2022). IIoT in Manufacturing: Delivering Value Through Optimized Workflows. McKinsey Industrial Practice Report.
Zhejiang Jigong Valve Co., Ltd.
Address: Dongou Industrial Park, Oubei Subdistrict, Yongjia County, Wenzhou City, Zhejiang Province (within Zhejiang Yinhe Machinery Manufacturing Co., Ltd.)
E-mail: Sales@cnzjsk.com.cn
WebSite: https://www.ball-china.com/
