2026-11-16
Edge or Cloud? Where Industrial Workloads Should Actually Run

Show notes
Should this workload run at the edge or in Azure? In this episode of the iFAKT series, we build a decision framework for placing manufacturing workloads: latency, bandwidth, resilience, security, cost and the role of Azure Arc and Azure IoT Operations. You will learn which production decisions belong near the machine, which belong in the cloud, and the architecture patterns that hold up when the plant loses its connection. Who it is for: Plant IT teams, OT engineers and Azure architects in manufacturing. Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-microsoft-365-azure-cloud-power-platform-ai--6704921/support. This episode includes AI-generated content.
Host: Mirko Peters
Transcript
Read the full transcript
iFAKT - Edge or Cloud - Where Industrial Workloads Should Actually Run 00:00:00 Speaker: Imagine your plant loses its internet connection halfway through a shift, while the inspection queue keeps growing and the next shift starts arriving at the gate, the line still needs to run. Have you lost cloud access or production capability? We'll work through that distinction. Workload by workload, using factory failures to decide what belongs near the machine and what can run in Azure. Starting with the production decision at risk. Before I ask where an application should run, I ask what happens when its result doesn't arrive in time or arrives with the wrong answer. That gives us a starting point. A delayed production report might leave a manager waiting until tomorrow morning. A delayed inspection result could let a defective pack move downstream, where someone now has to find it, contain it and work out which other packs need checking. Those failures need different treatment. If both appear on a project plan as data processing. You've hidden the difference. That should drive the placement decision before anyone chooses hardware or an Azure service. Let's use one hypothetical plant throughout this discussion. It runs a packaging line with inspection cameras, some shared plant services, and Azure Analytics that help engineers review performance across production runs and compare recurring losses at the line. A camera checks each pack before it leaves inspection elsewhere. A production engineer reviews defect trends, while a supervisor uses current production information to decide whether the shift needs attention or can keep running as planned. These jobs share data, but their consequences differ. The camera result supports a decision about a particular pack moving through a physical process. While the trend analysis supports a decision about how to improve that process over time. Start with the inspection decision. If the result arrives too late to affect the pack it describes, a correct answer still fails its purpose because production has already passed the point where that answer could help. Now consider the engineer's trend report. A delay might postpone an investigation, but it doesn't automatically mean today's packs escape inspection or that the packaging equipment needs to stop while the report catches up. That's the first placement rule I'd use. Describe the production consequence before you describe the preferred platform, because otherwise it's easy to give a report the same availability demands as inspection or inspection, the same tolerance for delay as a report, we also need to separate wrong answers from missing answers. A service that clearly reports result unavailable gives production a known condition to handle, while a service that returns a plausible but incorrect answer can push a bad decision into normal operation. The response depends on the job. Missing data might mean a gap in an analysis, a held PAC, a pause process or a condition that the equipment's design controls must handle without waiting for an external recommendation. Be specific about that boundary. Data collection records what's happening? Inference applies a model to new input. Operator advice supports a human decision, and machine control acts on the equipment within its defined operating rules. Inference simply means applying an already trained model in our hypothetical plant. That could mean asking a model to classify a camera image, with the result then used by a separate part of the inspection process. Don't let the application name blur those responsibilities. Calling the whole thing an industrial AI inspection system tells us very little about which job can tolerate delay, which job affects a PAC, and who owns the response when something fails. I'd put the production owner into this conversation early. Ask the quality lead what an unavailable inspection result means for product release and asked the line owner what a missing recommendation means for the next production step. Their answers established the cost of failure. That cost includes scrap rework, lost output and missed delivery commitments, but it can also include an unsafe action which needs treatment beyond a normal comparison of hosting costs. Then ask when the result stops being useful. A deadline tied to a moving pack creates a different placement requirement from advice needed before tomorrow's shift, even when both jobs use the same production records. We haven't chosen Edge or Azure yet. We've established what each workload must protect, how long production can wait, and which failure the plant must handle when the answer doesn't arrive or can't be trusted. That's enough to challenge a single placement for the whole application. Our packaging plant has several jobs with different deadlines and failure costs, so the next step is to separate those jobs before we assign them a home. Follow a single pack through the inspection system before anyone calls this one application, let's trace the separate jobs that turn a camera image into a production action and then into evidence someone can use later. First, the camera needs to capture a usable image. That job depends on the trigger, the lighting and the pack's position. So the equipment team needs to define what counts as a successful capture. The image then reaches the defect check. Whoever owns that check needs to specify its expected input and output, including how it reports an image that it can't assess with enough confidence. Next comes the reject request. A separate piece of logic connects the inspection result to the correct pack, then submits the request through the interface agreed with the equipment team. Saving evidence follows a different path. The image and its inspection result might need to remain available for a quality review, but saving them doesn't necessarily need to finish before that pack leaves inspection. Model training sits further away from that immediate sequence. Engineers can use images from completed production runs to build and assess a new model, without asking each pack on the line to wait for that work. We've now split inspection into jobs we can place separately. Each job needs its own deadline and owner, because responsibility for camera capture doesn't automatically include responsibility for evidence, storage or the next training run. I'd ask the teams to describe their handoffs in plain language. The camera team promises a usable image linked to a pack, while the inspection team promises a result that the next job can interpret without guessing, those promises need limits. If the camera supplies no image or the defect check returns an uncertain result. The receiving job needs an agreed response rather than an assumption buried in application code. This changes how you discuss hosting. Instead of asking whether inspection belongs in Azure, you can ask which jobs must execute locally and which jobs gain something. From access to data across plants. Our hypothetical plant could keep the immediate inspection sequence local. The accepted model runs near production, while images selected for engineering work reach Azure for later training and comparison with results from other lines. That split gives the cloud work a distinct purpose. It can help engineers find patterns across production runs and assess model changes, while the local system applies the version already accepted for production use, but separate jobs can still share a hidden dependency. Suppose the local defect check asks a remote service which model file to load whenever the application starts, even though the image processing itself runs inside the plant. Now imagine that application needs to restart without cloud access. Its processing code and model file might both sit locally, yet the startup sequence can't finish because nobody's separated. Model selection from remote configuration evidence storage can create the same kind of coupling. A developer might require confirmation from a remote archive before releasing the inspection result, turning a later record keeping job into a condition for the immediate production action. Neither dependency becomes obvious from the names of the services. You find them by asking what each job must wait for before it starts, before it returns a result, and before it can accept the next pack. Include shared components. In that discussion. Two applications can run as separate processes, yet still rely on the same configuration, service, database or application library to complete their work on every cycle. The practical output is a description of the handoffs for each job. Write down what enters, what leaves, who accepts that output, and which other service must respond before the job can finish its own work. Then challenge every required weight. Some weights belong in the production sequence, while others exist only because the software grew around a convenient shared service that nobody expected production to depend on. You can now assign locations to jobs rather than application labels. The next question becomes more precise when we choose local execution. How close to the equipment does each job actually need to sit? And what does edge mean in that choice? Edge needs a location attached to it. When someone proposes an edge deployment, I want to know whether they mean a computer inside a machine cabinet, a server beside the line, or shared infrastructure elsewhere in the plant. Those locations create different paths to the equipment. A computer can sit on your premises and still depend on several network connections. Before it can exchange a single message with the machine it supports, I'd name the locations before comparing them. For our packaging plant, we'll distinguish machine edge, line edge, and plant edge, then describe how each location connects to services. Running remotely in Azure Machine Edge sits beside or inside a particular piece of equipment. That might mean an industrial computer installed in the inspection station, with a direct connection to its camera and an interface to the packaging equipment. Its scope stays close to that equipment. The computer belongs to a specific station so its wiring, available space and operating conditions follow the machine rather than the needs of a shared server room. Physical conditions count here. A cabinet beside packaging equipment may expose the computer to heat, vibration, dust or cleaning practices that don't belong anywhere near a normal office desktop. Line edge moves the boundary out a little. Instead of placing a separate computer at every station, you provide computing close to one production line and connect the relevant stations through that lines network. That creates a shared location for line level work in our plant. Several inspection stations might connect to a line server, while each station still keeps its own camera connection and equipment interface where required. Close describes the connection as much as the floor space. A server twenty metres from a camera might require traffic to pass through shared network equipment elsewhere in the building before reaching its destination plant. Edge covers a wider area. This is site level computing, storage and integration that supports equipment across the factory, often from a dedicated server room rather than a cabinet near production. The plant boundary gives those services their scope. A site application might collect information from several packaging lines and make it available to other applications within the factory using connections managed as part of the plant network. You don't need to call every local server an edge device. If Plant Server tells the maintenance team exactly where a service runs, that's often a clearer name than another broad label on the architecture document. Azure extends beyond that site boundary. Your application uses remote services reached through the plant's external connection with access to infrastructure and managed services that don't need to sit inside each factory. That wider reach changes what you can share. Engineers working across several plants can use a common remote service without each plant hosting its own copy provided the connections and application design support that arrangement. Managed infrastructure changes the division of work. Depending on the Azure service you choose, Microsoft handles parts of the underlying platform while your team still owns the application choices and its connections to production. These locations can co-exist within one plant. You might have a computer at an inspection station, a server serving that packaging line, shared site infrastructure, and Azure services, each with a clearly stated role. The names alone won't tell you how a drug behaves. A machine side computer that reaches through a plant server for every request has a different operating path from one that exchanges information directly with the equipment. Trace the actual connections between those locations. Ask which network segments a message crosses, which intermediate service receives it, and whether the reply follows the same route back to the application, waiting for it. Distance on the floor plan only answers part of the question. A nearby server can introduce a long or variable weight through shared services, while a more distant service might respond quickly during normal operation over a well-performing connection, so replace it runs at the edge with a concrete description. Name the computer's location, the equipment it serves, and every connection it needs. Then ask how long that complete path takes to return a usable result. Real time doesn't give us a requirement. We can test. When a team uses that phrase, I ask them to name the physical event that sets the deadline and the latest moment. The result can still affect it for inspection. That event follows the pack's movement. The available time starts when the system captures the image and ends before the equipment must commit to the action for that particular pack. That interval is our response budget. We need to establish it from the actual process, including the packs, position and speed, rather than choose a round number because an application usually responds within it. The deadline belongs to production, not the software team. An application developer can explain how long processing takes, but the equipment and process owners need to establish when the receiving system must accept the result. Let's follow that budget through our packaging line. After image capture, the image must become available to the inspection application, which then prepares the input, runs the defect check and passes its result onward. Processing uses only part of the available time, transferring the image, waiting for computing resources, and passing the result through the receiving interface. All consumed time before the equipment can accept an action for that pack. Acceptance needs a precise meaning here. A message reaching a network connection doesn't necessarily mean that the receiving application has checked it, associated it with the right pack, and accepted it for use. I defined both ends of the measurement in writing, otherwise, one supplier might quote processing time from an image already loaded into memory, while another measures until the result leaves its application, leaving gaps nobody owns. Now give the process some margin. If the available response budget barely exceeds the measured processing path, normal changes in operating conditions can consume that gap before anyone notices a change in average performance. The margin needs a reason behind it. It should reflect the variation you observe and the conditions the plant expects to support, rather than an arbitrary percentage added to make the requirements sound cautious. Line speed can change the available budget, too. If production approves a faster operating rate, Pax reach the action point sooner, so a timing requirement accepted at the slower rate may no longer protect the process. Specify the operating range with the deadline a statement such as result accepted before this pack reaches the action boundary needs to remain true across the speeds and product conditions covered by the inspection design. Average response time won't settle that question. An application can deliver most results quickly, while a smaller share waits much longer, especially when other work competes for the same computing resources or messages accumulate production experiences those slower results one pack at a time. A shift average can look healthy, even though individual answers repeatedly cross the deadline, leaving the receiving equipment without a usable decision when it needs one. Consider a correct defect result that arrives after the pack passes the reject point. The model has classified the image correctly, but the inspection sequence has failed to deliver that classification within the process window. Quality now has a product handling problem. The late result can't simply attach itself to the next pack, because that would turn a missed deadline into an incorrect action against a different physical item. Timing belongs in the definition of a usable result for this job. Correctness includes identifying the right pack and delivering the answer before its deadline, not just assigning the right label to the image. That gives us a more useful placement question can the complete execution path meet the process deadline with enough margin for expected variation? Under the operating conditions we've agreed the line must support, there's still a stricter boundary ahead. Completing an inspection request before a defined deadline doesn't automatically qualify the same computer or application to run equipment control, where timing requirements can extend to repeated execution on a controlled schedule. That's a different engineering requirement. Before we let local placement imply permission to control a machine, we need to separate deadline bound analysis from the control functions responsible for how the equipment actually behaves. A programmable logic controller, or PLC runs equipment control close to the process. In our packaging plant, it reads equipment inputs and executes control logic that governs how the machine responds using timing and interfaces selected for that equipment. Its role extends beyond receiving an inspection answer. The controller also handles the machine sequence, which means an external application can't assume that a request becomes an action simply because it reaches the controller. Take a reject mechanism that's already completing a movement. The control logic needs to manage that movement within the machine's rules, rather than accept another request that conflicts with the current equipment. State or actuator limits. Give the inspection application a bounded way to ask. That interface should define the permitted request, the conditions under which the controller can accept it, and the response when the request doesn't meet those conditions, the controller retains authority over the equipment sequence and inspection application can supply a defect result, but the equipment design determines how that result enters the sequence and which operating limits remain enforced locally. That boundary needs agreement with the machine builder or control engineer. Connecting an application through an available industrial protocol gives you a communication route, but it doesn't establish that the receiving logic can safely interpret every message you send. Safety functions need their own engineering treatment. Where a function protects people from a machine hazard, it belongs within a safety system designed and validated for the required risk reduction. Using suitable equipment and engineering methods, a safety controller may form part of that system. Other parts can include protective devices and the means of stopping hazardous movement, with the complete function assessed rather than judging safety from a single component's name. Keep that distinction clear during an AI project, a camera model that detects a damaged carton doesn't gain permission to perform a personnel protection function just because it processes images quickly or runs beside the machine separate those responsibilities in the design. The inspection application handles its defined quality task, while the machine's protective functions continue through the safety architecture established for the hazards and operating modes of that equipment. Changes need review at that same boundary. If a new application can change operating behavior, the responsible engineers need to assess whether that change affects existing protective measures before anyone releases it into production. Local computing doesn't automatically provide controlled timing. A general purpose edge server may schedule background tasks, wait for storage, or share resources between applications, even when its network connection to the machine is short and fast. Deterministic timing means execution stays within defined, dependable timing bounds for a control task. Those bounds may need to hold through repeated cycles under specified operating conditions, supported by the full hardware and software design. An ordinary container deployment doesn't establish that guarantee. Specialized platforms can support time sensitive control, but that requires an engineered system and evidence for its timing behavior, not a decision to install software near production. 00:17:19 Speaker: I'd ask for the control requirements before discussing replacement hardware. If someone proposes moving a PLC function onto an edge computer, the review needs to address execution, timing, equipment interfaces, fault responses, and who will validate the change design that doesn't rule out useful edge analytics. A local application can assess equipment, condition or calculate a process recommendation, then pass an approved request through an interface that leaves the controller's operating limits intact. For example, consider a suggested adjustment to a packaging parameter. The receiving control logic can check the requested value against permitted bounds, and allow the change only in an operating state approved by the equipment design permission needs a clear owner. The process engineer defines what adjustment is acceptable. The controls team implements the receiving checks, and the application team stays within that agreed contract instead of writing directly wherever access happens to exist. Operator advice gives us more placement freedom. If an application suggests a setting for a person to review before the next production run, it can operate outside the immediate control sequence under a different set of requirements. That distinction opens up the placement choice. Once the equipment retains its design, control and safety responsibilities, we can assess advisory work on its own terms without treating every useful calculation as part of machine control. I'd capture that assessment in a workload placement record. It's a short working document that connects a specific production need to a proposed location, with enough detail for another engineer to challenge the decision without repeating every project meeting. Start with the job and its production owner. Write what the workload delivers, who relies on it, and who can approve changes to its operating requirements. When production conditions or business priorities change. Name a person or an accountable role, not just a department. Engineering won't resolve a disagreement about acceptable downtime. When the application team and the shift supervisor each expect someone else to accept the production risk. Give the record a narrow scope in our hypothetical plant. The inspection evidence service deserves its own record, because its storage requirements and recovery needs can differ from those of the application. Generating inspection results then attach a deadline to the promised output. Record the conditions under which that deadline applies, along with the production consequence. If the output arrives late, disappears or can't be trusted for its intended use. Keep the consequence specific enough to guide a decision. Reduced availability doesn't tell an architect much. While quality can't release the affected batch until the missing evidence is recovered, describes a business constraint that the design must address. Next, describe the data entering and leaving the workload. Record the expected rate and the busiest supported operating conditions using measurements where available and clearly labeled estimates where the equipment or application hasn't yet reached production. An estimate is a question waiting for evidence if image size varies by product. Note that variation, rather than letting a quiet trial run, become the assumed demand for every product the plant might later introduce, outage tolerance needs its own entry. State how long the workload can lose each required connection before its promised service changes, and have the production owner approve that limit rather than treating it as an infrastructure preference. Recovery deserves a separate target, the allowed interruption and the time needed to restore normal service. Describe different requirements so record how quickly the workload must return and how much missing data production can accept. Security requirements belong beside those operating limits. Record the sensitivity of the information, the permitted users and services, and any restrictions on where data can be processed or retained under the plant's approved policies. Don't turn this record into a security manual. Its purpose is to expose constraints that could change placement, such as evidence that must remain within a defined jurisdiction or access that requires approval from the equipment owner. List what local operation actually requires. Include the application, resources and dependencies needed to deliver its promised output, then distinguish what must already exist inside the plant from what can remain unavailable for an agreed period. Name every required cloud service explicitly. A general note saying as your connectivity required leaves the reviewer guessing whether lost access interrupts production work immediately or merely delays a supporting task that can wait. Now write the proposed placement and the reason for it. Plant server subject to confirmed storage performance and agreed recovery support gives the team a decision with conditions rather than a location presented as settled fact. Separate evidence from assumptions in that same entry, a measured result, a supplier statement and an engineering estimate carry different weight, so identify which one supports each requirement and who still needs to verify it. Give unresolved assumptions an owner and a review date. Otherwise, a provisional choice can quietly become the production standard, with nobody remembering that its acceptance depended on a test the project never completed before. Hand over the record also needs a review trigger, a faster line, a new product, or a changed service. Dependency should prompt reassessment when it affects the conditions used to approve the original placement. Keep revisions attached to the decision when someone asks why a workload runs locally, you should be able to name the requirement that drove it, and the evidence supporting that choice, rather than rely on whoever remembers the workshop. That gives us something concrete to test for any workload whose proposed location relies on network communication. The next task is to check whether the complete path supports the promise written in its record. A network test can pass while the production path fails. A quick reply between two computers tells you little about the time and inspection request spends waiting inside the applications connected through those computers. Instrument. The actual inspection transaction give a test image a traceable reference, then record when each receiving component accepts it, and when that component passes its output to the next job in the sequence. Use those records to find where time accumulates at the camera gateway, for example, distinguished time spent transferring an image from time spent waiting for the gateway to collect, prepare, or release that image. A gateway might send images in batches that can improve transfer efficiency, but the first image in each batch waits for the remaining images before any downstream application even starts working on it. Queues need their own measurements. Record how long a request waits before processing starts, because a fast defect check can sit behind earlier requests long enough to miss its production deadline. Check the receiving control interface as well. The inspection application might finish promptly, while the service handling its result to the controller waits for its next scheduled exchange, or retries a request that hasn't received confirmation measure elapsed time at each handoff where practical. If separate computers supply timestamps, verify their clock agreement before subtracting those timestamps, or you might report a delay that comes from clock error rather than processing. Start with a quiet baseline, then introduce representative demand in our hypothetical plant. Run the inspection path while the other approved applications consume computing resources, and the shared network carries its expected production traffic. Change one condition at a time. Where possible, if requests slow down when another application reads large files, you need enough evidence to distinguish storage contention from network congestion before changing the proposed placement. Watch what happens when several cameras trigger close together. A test that feeds images at evenly spaced intervals can miss the short bursts that occur when separate stations reach the same point in their cycles. Retries deserve particular attention during these tests, a request that receives no prompt reply may trigger another attempt, adding more work precisely when the receiving service already struggles to keep up with existing demand count requests as well as completed results. Otherwise, a service can appear fast because the measurement includes only successful replies, while the requests that timeout disappear from the performance report entirely, report the deadline miss rate directly. That's the share of requests that fail to deliver a usable result within the agreed window. Measured against all requests, the inspection path should have handled, then examined the slow end of the response times. Engineers often call this tail latency, meaning the delays experienced by the slower requests rather than the typical request passing through the system under test. A percentile helps describe that slow end. If you report the ninety ninth percentile, you're naming the response time at or below, which ninety nine percent of the measured requests completed during that particular test. That figure still leaves slower requests outside it for a production decision with a firm deadline, keep the individual misses and their operating conditions rather than letting a percentile replace the acceptance requirement. Run the test long enough to encounter routine background work. Scheduled scans, application housekeeping, and other approved tasks might affect resource use only occasionally, so a short demonstration can avoid the very conditions you need to measure. Use the plant environment for acceptance testing. An office network trial can help check instrumentation, but it doesn't represent the approved routes, gateway settings, equipment interfaces, and competing traffic that the production deployment will actually use. Keep testing controlled around operating equipment. Coordinate with production and the controls team. Use test modes or a suitable test environment where needed, and avoid creating congestion on an active control network just to collect measurements. The result should support a specific placement decision. You might discover that the proposed plant server meets the requirement, or that an intermediate service consumes enough time to require a different execution path. Keep the tested conditions attached to that conclusion. Passing under representative load establishes evidence for those conditions, but it doesn't establish how the workload behaves. When a required connection disappears or a responding service becomes unreachable. Disconnecting the plant creates an operating condition that needs its own rules. For each workload, the production owner needs to approve what service remains available without the external link and what changes the people on shift should expect. Choose that behavior before the outage, a workload might continue normally, provide a reduced service pause until a required connection returns, or ask the equipment to enter its designed safe stopping sequence. Those choices need clear conditions. Continuing means the workload still meets its approved requirements, while reduced service means production accepts a defined loss of capability within limits that everyone involved understands beforehand. Reduced service needs a practical description for our packaging. Plant inspection might remain available for the product already running, while switching to another product stays blocked until its approved production information becomes available. That gives the supervisor a usable boundary. The line can finish the current run under agreed conditions, but nobody treats the missing connection as permission to improvise a recipe for the next order. Pausing also needs a defined scope. An engineering review can wait without interrupting packaging, whereas a missing production prerequisite may prevent the next run from starting. Even though the current run can finish, a stopping decision belongs with the responsible equipment and process engineers. Their design should specify how the process reaches an acceptable condition when a required service disappears, rather than leaving the application team to invent an outage response. Now consider what the shift actually needs locally. The plant needs access to the approved recipe. The accepted inspection model and the instructions that let operators complete the work permitted during that disconnected period. Availability alone doesn't settle whether those materials are usable. Each local copy needs a clear approval status and a defined scope, so operators know which product and operating conditions it supports without asking an unreachable service. Product changeovers deserve their own check if the next order requires different settings or inspection criteria. Determine whether those approved materials must reach the plant before the previous run finishes or before the external link disappears. Instructions can hide an unexpected dependency. A workstation might display the current procedure perfectly during normal operation, yet open only a remote document reference when someone needs the fault recovery steps during an outage. Give operators the instructions for the permitted disconnected work. That includes the limits on continuing production and the point at which they must pause with wording that doesn't require them to interpret an infrastructure alarm, the less obvious dependencies need closer attention. An application might contact an external service to confirm its license, refresh configuration or obtain a required reference value. Even though its main processing takes place locally, ask when each contact occurs. Some checks happen on a timer or after a local change, so a brief disconnection test can pass while a longer outage reaches a condition that the test never exercised. Identity checks can create a similar delay and failure. Someone already using an application may continue working, while a person arriving later can't establish a new session because the required identity service can't be reached. Shift change makes that difference concrete. Imagine the external link fails near the end of the afternoon shift, and the incoming operator needs to sign in before accepting responsibility for the packaging line. The outgoing operator screen still works. That doesn't prove the incoming operator can reach the approved instructions or confirm the next task under their own access, and borrowing an open session isn't an acceptable operating plan. Test the incoming shifts. Actual workflow. Ask whether an authorized person who wasn't already signed in can perform the work the outage plan permits using the access arrangements approved for that operating condition. Duration belongs in the test to a workload that continues through a short interruption. May change behavior later when a routine check falls due, or information needed for a production decision reaches its approved age limit, make those changes visible to the shift. Operators need to know which functions remain available and which actions are blocked, with clear instructions for when continued operation no longer meets the agreed conditions. Disconnected operation also leaves records waiting to leave the plant if packaging continues while Azure remains unreachable, inspection evidence and production events keep arriving locally, creating a storage obligation that grows for as long as the connection stays down. Store and forward gives those waiting records a defined home. The application writes them to temporary local storage, then sends them onward when the destination becomes available, keeping each record until the agreed delivery condition permits removal. That storage has a limit. Saying we'll buffer locally leaves the design unfinished unless you specify how much data fits, how long it must remain there, and what happens when space runs short? Size it from the Workload's actual storage rate for our inspection evidence service. Measure the bytes written during the busiest supported production conditions, including the records and storage overhead that accompany each saved image. Then apply the outage window. The plant has approved. The starting calculation is storage rate multiplied by the time without delivery, with extra capacity for the variation and operating margin, your measurements show you need use usable space, not the capacity printed on the drive. The operating system, application files, local logs and storage maintenance all need room, so the buffers allocation must exclude space. Those other functions require to keep running, check whether production can increase that rate. A second camera or a product requiring larger images can shorten the supported outage window without changing the disk. Even though nobody has touched the buffering application itself. The buffer needs a storage contract, specify which records it holds, their retention limits, and the condition that releases space, rather than assuming that writing a file means someone else will eventually manage it. Delivery and retention aren't always the same obligation a record might leave the forwarding queue after confirmed delivery, yet still need a local copy under the quality policy. Consuming storage outside the temporary buffers allocation separate those allocations in the capacity calculation. Otherwise, a queue that appears to drain successfully can leave the disk steadily filling with retained evidence until a later outage exposes much less free capacity than anyone expected. Not every waiting record deserves the same treatment. The quality team might require inspection evidence to remain intact, while the plant permits routine telemetry to expire after a shorter period under a documented retention rule reserve space according to those approved priorities. If quality evidence and alarms share an unrestricted queue with routine telemetry, a busy stream of low priority records can consume the capacity needed for information the plant can't afford to lose. Priority needs to affect admission as well as deletion. A system that promises to protect alarms must still accept an alarm when routine traffic has reached its own limit, which means enforcing separate allowances or another tested reservation method. Set thresholds before the buffer reaches capacity at each threshold. Define the warning, the person responsible and any permitted change in data acceptance, giving the shift enough time to act before records start disappearing. Warnings need time attached to them. Free space alone tells an operator little while an estimate based on the current write rate can indicate how much longer the buffer can accept records under present conditions, that estimate needs caution. When demand changes, it should support an agreed response rather than promise a fixed remaining runtime. Because a change in product or inspection activity can alter the rate while the warning remains active, full disk behavior must be deliberate. Depending on the approved requirements, the service might refuse new low priority records, remove records whose retention has expired, or declare that it can no longer accept required evidence. Silent overwriting isn't an acceptable default for required records. If quality requires evidence for release, losing the ability to save that evidence must trigger the agreed product handling response, with the affected production clearly identified for the shift. Also check what a full buffer does. Upstream backpressure means a downstream service slows or stops accepting work, causing the sender to wait, retry, or hold its own records instead of completing its normal handoff. That pressure can travel beyond the storage service. If the inspection application waits indefinitely for a buffer, write an evidence storage problem can block new inspection work, so every receiving boundary needs a bounded wait and an explicit failure response. Test that behavior with the allocation nearly exhausted. Confirm that required warnings appear. Reserved space remains available and the application follows the approved rule instead of failing unpredictably when the next write needs more room. A full buffer isn't the only difficult condition. When delivery resumes, the plant still produces new records, and the waiting backlog needs a controlled way out without consuming the resources required for current production. The connection returns, but normal service doesn't return with it. Our packaging plant now has current inspection records arriving alongside stored records awaiting delivery, and both streams compete for the same sending capacity and downstream processing. Recovery needs its own operating plan. If every local sender immediately transmits at full speed, the receiving services can slow down or reject requests, leaving the plant connected but unable to clear its waiting records reliably. 00:34:23 Speaker: Give current traffic an explicit share of available capacity, then limit backlog delivery to a tested rate. That leaves room for current production. Adjusting that rate when the destination reports pressure or takes. There's another way to reduce the transfer burden. Choose what needs to travel before expanding the connection. Examine whether every camera frame and every vibration sample needs to leave the plant for the receiving job to do its work. Start with the question the data should answer. An engineer comparing defect rates across completed runs may need inspection results and selected images rather than every frame the cameras captured while those runs were in progress. A vibration workload presents a similar choice. A condition monitoring application might send calculated measures that describe the signal over an interval, while keeping the detailed waveform locally for investigations that need the original samples. The reduction comes from local processing instead of sending the entire input stream. A local application extracts the result or measure needed by a downstream task, reducing traffic before transmission starts. But each reduction changes what someone can examine later. A summary might reveal that vibration increased, yet leave an engineer unable to distinguish possible causes that require the frequencies and timing contained in the original waveform. Treat each reduction as an engineering decision. Ask the receiving team which questions the reduced data, supports which questions require raw evidence, and whether losing that evidence would prevent an investigation they need to complete. Filtering removes records according to a rule. For example, an application could exclude repeated camera frames that don't contribute to an inspection record, provided the rule preserves the images needed for the quality task. Compression changes the representation rather than simply selecting records. Lossless compression allows the original data to be reconstructed exactly, while lossy compression removes detail to reduce size, which may affect what an engineer or model can detect. Validate compression against the intended use. An image that looks acceptable to a person might lose a faint surface feature that matters to defect detection, so visual appearance alone doesn't establish that a compressed copy remains suitable. Event based capture gives you another option. A local application can preserve detailed data around a defined event, rather than sending continuous raw data from equipment whose behavior rarely changes enough to warrant investigation. Capture the lead up as well as the event. If abnormal vibration triggers preservation. A rolling local recording can retain samples from before the trigger, helping engineers examine how the condition developed rather than only its aftermath. The trigger still limits what you'll retain. A rule that saves images only when the inspection model reports a defect gives engineers examples of detected defects, but excludes the missed defects they may most need to understand. Consider a later investigation at our hypothetical packaging plant. A downstream check finds packs with a faint seal defect and quality. Asks engineering to review the images from the inspection station that passed those packs. The archive contains only rejected pack images. The team chose that filter to reduce traffic, but now the surviving evidence can't show whether the defect appeared in the captured images or escaped the camera altogether. Those possibilities call for different corrective work. If the image contains the defect, engineers can examine the inspection method. If the image never captured it clearly, they need to investigate lighting, positioning, or another part of image capture. The filter has removed that distinction. Engineers may need to reproduce the condition before they can test either explanation. While quality works with less evidence about the affected production than it expected to have. Use that possibility when setting the capture policy. Depending on the investigation needs, you might retain a sample of accepted pack images, preserve raw data during product trials, or increase capture when a new defect emerges. Model development also needs deliberate sampling. A collection dominated by obvious rejects can leave the training and assessment work short of normal variation. Borderline cases and defects. The current inspection method doesn't recognize quality requirements. Set some limits before bandwidth enters the discussion. Where an approved procedure requires particular evidence, the transfer design must preserve that evidence in an accepted form and location, rather than discard it to meet a traffic target. Bandwidth savings are measurable. Lost questions are easier to overlook. I'd approve a reduction rule only after the people using the data have named what they can still investigate, and what evidence they'll no longer have when something unexpected appears, A saved measurement still needs a clear manufacturing, meaning an inspection value that reaches Azure without its production context can remain perfectly readable. While telling the receiving application very little about the work it actually describes. Consider a sealed temperature reading from our packaging line. Before an engineer can interpret it, the record needs to identify the asset, the measurement unit, when the reading occurred, and whether the source considered that reading valid. The number alone leaves too much open. A temperature associated with the wrong sealing station could send an investigation toward equipment that never touched the affected packs, even though the value itself transferred without error. Give the asset a stable identity. Local controller names and maintenance labels can remain useful, but the receiving systems need an agreed mapping that distinguishes one physical resource from another across the plant. Units need the same care if one source reports degrees Celsius and another uses a scaled integer, the receiving application needs the declared unit and conversion rule before it compares their values. A timestamp also needs a defined meaning for a machine reading record, whether it describes the moment of measurement or another event, so downstream applications can associate the value with the production activity occurring. Then quality status belongs with that reading, a value held from an earlier measurement because the source couldn't obtain a fresh reading shouldn't quietly enter an analysis as though it describes the current process condition. Now connect the reading to the work. The Enterprise Resource Planning System, or ERP supplies business contexts such as production orders and material requirements, while the manufacturing execution system or Mes supplies execution context from the shop floor, those systems describe different parts of production. Your integration needs to establish which record supplies each piece of context, rather than let whichever system responds first. Determine what an event means to the receiving application. Our seal reading might belong to a particular order. That order identifies the product being produced, while the execution record identifies the operation and resource involved when the measurement occurred, giving engineering a way to interpret the reading against that work. Changeovers expose weak associations quickly. If an application attaches whichever order is currently active when it processes a reading. A delayed record from the previous run can acquire the next order's identity, keep the association tied to the production event where context arrives separately. The system needs a reliable way to match the event to its execution record and to flag unresolved matches rather than quietly invent them. Local and cloud applications need compatible definitions. If the plant calls an order complete when packaging finishes, but a cloud calculation assumes completion includes quality release, the same status can support two different decisions without anyone noticing. Write those definitions into the data contract. That's the agreement describing what each record means, including how product, process and resource identifiers relate, and how changes to those definitions reach the applications using them. A replacement machine makes this practical. The new equipment might occupy the same station and produce the same product, but engineers still need to distinguish measurements from the old resource when comparing performance across the replacement date. Some relationships fit ordinary reference tables if you only need to connect each event to an asset and an order, a maintained mapping may solve the problem without introducing another modeling platform. More connected questions can justify a knowledge graph. It models relationships explicitly so an application can follow an order to its required process, then identify which resources can perform that process for the specified product. A digital twin can organize context around modeled assets and processes. Its usefulness depends on the relationships and state your team maintains, so choose that approach when the questions require it rather than because the label sounds industrial, neither approach supplies the factory model automatically. Manufacturing teams still need to define what each relationship means, which source maintains it, and how applications recognize that a relationship has changed since an earlier production. Run. Placement now includes responsibility for manufacturing, meaning a local service and an Azure application can process different copies of the same records, but they need enough shared context to reach compatible interpretations of the production those records describe that context also defines what each recipient can learn once records connect equipment behavior to products and orders. The next design question concerns which systems should receive that connected information and where its trust boundary belongs. Connected production records need protection wherever the workload runs. Moving an application inside the factory changes its exposure, but you still need to control which systems can reach it and what those systems can do. Information technology, or it often manages business applications and enterprise access. Operational technology or OT manages systems whose behavior affects physical production, so a security change can affect equipment availability as well as access to information. Recovery creates different pressures for those teams. Rebuilding a business workstation might follow a standard process, while restoring a production computer may require supplier involvement and checks before the connected equipment can resume work. That difference should shape the security design before adding a scanner, agent or network restriction near production. Agree how you'll assess its effect on the supported equipment and obtain approval from the responsible engineers. Start with network zones and permitted communication between them. In our packaging plant, an analytics service, collecting inspection records shouldn't gain unrestricted access to equipment simply because both services connect to the same local infrastructure. Give each connection a stated purpose. Describe which application initiates it, which destination receives it, and what traffic is permitted. Then configure the network controls to enforce that specific route rather than broad reachability. A boundary service can separate collection from external delivery. For example, an approved intermediary in an industrial demilitarized zone, a network segment between protected environments can exchange selected records without giving external applications direct access to production equipment. The intermediary needs protection to its permitted connections should match its assigned task. Because a server that bridges environments with broad access can become a route around the separation you intended to create. Application permissions need equally narrow boundaries. Give the evidence forwarding service its own identity, and only the access needed to read approved records and deliver them to its assigned destination without permission to alter equipment settings. Separate identities make investigations more precise. If several applications share one powerful account, an unexpected connection tells you less about which workload initiated it, and restricting that account can interrupt unrelated services. Outgoing connections can reduce some exposure. A plant service that initiates delivery to Azure may avoid an externally reachable listener, but the connection still carries information and receives responses that need appropriate checks. Outbound doesn't automatically mean safe, compromised software can use an allowed external connection to send production information elsewhere, so restrict destinations where practical and examine what each permitted flow can carry across the boundary. Check the receiving end as well. The application should verify the destination's identity through correctly configured certificate validation, rather than accept any endpoint that answers at an expected address or presents a familiar name. Local equipment has physical exposure that cloud architecture discussions can miss. A computer beside the line may have accessible ports or removable storage, so cabinet access and service procedures belong in the workloads. Security assessment restrict access without blocking authorized maintenance. Decide who can connect service tools, which media they can use, and how those actions are recorded. Based on the equipment's support needs and the plant's approved practices. Secrets need a defined storage method. Passwords, access tokens, and private certificate keys shouldn't sit in plain text configuration files, copied installation folders, or shared maintenance notes that grant access beyond the person using them. Choose protection the deployed platform actually supports use restricted secret storage and appropriate hardware backed protection where available, while limiting which processes and administrators can retrieve or use the credentials assigned to each workload. Software delivery creates another entry point. A legitimate deployment account can install a compromised package, so control where application images and updates come from and verify their origin before they reach production infrastructure. Keep track of the components you deploy known versions and a software bill of materials and inventory of included components. Help the team determine whether a reported vulnerability affects the workload actually running at the plant. Security controls need an operational test? Confirm that permitted work still succeeds and prohibited access fails without using intrusive tests against active equipment. Unless the responsible team has approved the method and conditions, there's one access condition still worth separating controls that work, while every supporting service remains reachable, can behave differently during disconnection, which means the plant also needs an approved way to protect access when those services can't answer. Disconnected access starts with two separate questions who can authorize a person to work, and what allows one application to communicate with another when the normal identity services can't answer from outside the plant? Those access paths need separate designs. An operator might need permission to acknowledge a quality hold, while a background service needs permission to write evidence without borrowing that operator's session or account. Start with the permissions required during an outage. Give each permitted task an access method that works for the agreed disconnected period, while keeping changes to permissions under the control of an approved authority. Cached permissions create a specific trade off. They let a local application use an earlier authorization decision, but that application might not learn that someone's access has since been revoked while the connection remains unavailable. Set a maximum age for that decision. The security owner and production owner need to agree how long cached permissions remain acceptable, which tasks they cover, and which actions require a fresh authorization. Acknowledge the revocation gap explicitly. If immediate removal of access is a requirement, the plant needs an approved local way to block that person, rather than depending entirely on an unreachable central service. Machine access follows a different clock. A service might continue exchanging records until its certificate expires, or a required token needs renewal. Even though nobody has changed the application or its local configuration, expiry doesn't pause when the connection fails, check the remaining credential lifetime against the supported outage duration, including whether renewal needs an external identity provider, certificate authority, or another service outside the site. Certificate checks need attention beyond the expiry date. Depending on the implementation. Validation can also require access to revocation information, so establish how the deployed software behaves when that information can't be refreshed during disconnection. Don't solve that problem by disabling validation. Choose an approved validation and renewal design for the required outage window and test the actual applications. Because different clients can handle an unavailable Check differently. Credential rotation needs an overlap. Plan to. If a replacement credential reaches one application but not its local counterpart before disconnection, both applications can remain healthy while their connection fails because they no longer accept each other. Test renewal boundaries not just ordinary access in a controlled environment. Move through the conditions where credentials expire or permissions need refreshing. Then verify that each workload follows its approved access rules without unexpected exceptions. Emergency access belongs outside the routine login path. A controlled local emergency account can support narrowly defined recovery tasks when normal access fails, with approval rules and restrictions established before anyone needs to use it. Keep that account out of everyday work. Protect its credentials, limit what it can change and record who authorized its use and which person performed the actions, even when the account itself isn't individually named. Local audit records must survive the outage record. Successful and failed access attempts, emergency actions and permission changes locally with protected storage and enough clock information to support a later review of the sequence. Reconnection should trigger reconciliation, not silent cleanup. Transfer the retained audit records through the approved route. Review emergency access and replace exposed emergency credentials according to the procedure. Before treating that access path as ready again. Access location also affects data residency. A database inside the factory doesn't settle where its contents can travel. If administrators export diagnostic files, support tools, upload logs or backup services, copy records elsewhere. Follow the information through those support activities. Identify which records can leave the site, where each copy is processed and retained, and which contractual or regulatory restrictions apply to the people who can access it. Retention rules need to cover secondary copies. A production record deleted under an approved policy might still exist in a support attachment or diagnostic archive, so those locations need their own documented handling and deletion rules. Remote support deserves a bounded permission window. Give the approved person access to the systems needed for the task. Record the activity and close that access afterward, rather than leaving a permanent route available for convenience. Put these decisions into the operating procedure. The incoming shift needs a workable access method, While the person responsible for security needs evidence that disconnected production hasn't quietly become an exception to every normal permission boundary. An access procedure still needs someone available to carry it out at two in the morning. Our hypothetical packaging plant needs a support arrangement that connects the person beside the equipment with someone authorized and equipped to resolve the fault. Start by assigning ownership to the physical computer. Someone needs responsibility for its power supply, cooling, storage, and replacement parts, including the practical work of finding a failed unit and arranging access to its cabinet. Assign the operating system an application separately where necessary. The team that replaces a disk might not know whether the inspection software can restart correctly, so the handoff between those teams needs an explicit acceptance check. Production impact needs an owner as well. A support engineer can confirm that a service responds again, but the designated production authority decides whether its restored behavior permits the line to resume the affected work. Right. The escalation path around decisions, not just phone numbers. The person on shift should know whom to contact first, how long to wait for a response, and who takes over if that contact doesn't answer. 00:51:46 Speaker: Avoid leaving. Contact the supplier as the final instruction. Check whether the support agreement covers the hours the plant operates, what information the supplier needs, and whether someone at the site must assist before diagnosis can begin. A spare computer only helps if it's ready for the job. Its connections, supported software and configuration need to match the intended replacement role, with a documented method for restoring the plant specific settings that aren't part of a standard installation. Check where that spare actually lives. A replacement in another building behind a locked store's counter won't meet the same recovery expectation as a prepared unit that the authorized maintenance technician can reach during the night shift. Replacement work also needs a clear limit. Specify which tasks trained site staff can perform and which require a specialist, so nobody discovers during a fault that changing the unit requires skills unavailable until morning. Remote support needs a local partner when physical checks become necessary. Agree who can identify the correct cabinet? Read an indicator or check a cable under the site's approved procedures without asking an operator to attempt unfamiliar electrical work. Arrange site access before the callout happens, an external engineer may need an escort, an induction or permission to enter a restricted production area, and those arrangements can determine when repair work actually starts. Patch windows need production agreement rather than a convenient calendar slot. The maintenance plan should name the workloads being interrupted, the people required for the work, and the checks that must pass before the window closes. Allow time to reverse an unsuccessful change. If an update disrupts an application, the team needs an approved return path and enough remaining time to use it before production expects the equipment back. Local health information should support those same people. When cloud monitoring isn't reachable, the site still needs a way to check server status, resource pressure, and recent faults through an interface available within the plant. Make those signals useful to the first responder application stopped and application running by producing no new results. Describe different conditions, so a simple running process indicator shouldn't become the only measure of whether the service works. Health messages need an action attached. Tell the technician which observations to collect and which conditions require escalation. Rather than present a long fault code that only the absent application developer can interpret. Recovery instructions need to survive a tired reader. Use the equipment, names and labels found at the site. Identify the permitted actions in sequence and state where the person must stop if the expected response doesn't appear. Have an actual shift team try those instructions. A controlled rehearsal can reveal missing tools, inaccessible logs, or an assumed skill that the author didn't realize. The person following the procedure would need to complete the task. Measure the recovery work, including the waiting time spent finding the right person or obtaining a cabinet key belongs in the operating reality, even though neither appears in the application's own restart time. That operating effort belongs in the placement decision. Before comparing the cost of a local server with Azure account for the people, support coverage and prepared equipment needed to keep that server useful throughout the plant's working hours. A purchase price won't tell you the cost of placement. Compare the expense of delivering the same approved service over a common period, including the work and capacity. Each option needs to meet production requirements. Keep the comparison like for like. If the local proposal includes recovery capacity, but the Azure estimate includes only normal processing, your pricing, different levels of service, and calling the difference a saving for local computing spread. The initial investment across its expected service life include installation and commissioning alongside the hardware, then account for power cooling support contracts and the spare capacity required by the approved operating design. Refresh costs deserve a place in that calculation. A service replacement can involve application testing, supplier checks and migration work, so the eventual expense extends beyond ordering. Another computer with roughly the same processing capacity. Shared infrastructure complicates the allocation. If our packaging inspection workload uses an existing plant server, charging it, the whole server overstates its cost, but treating its use as free hides consumption that could force an earlier expansion. Calculate both the immediate and longer term effects. There's a difference between fitting another workload into spare capacity today and committing the plant to buy more capacity. When several projects grow together over the next few years, Azure requires the same discipline estimate compute from the actual execution pattern, then includes storage, data ingestion, and the managed services the application needs using the selected service tiers and deployment regions rather than broad assumptions, networking charges depend on the route and service. Check the applicable pricing for transfers between locations and services, including data leaving Azure where charges apply. Instead of applying a single rate to every byte the application handles stored data keeps costing money after processing ends. Our packaging plant might generate inspection evidence once, yet pay to retain it for the approved period, retrieve it during investigations and maintain additional copies required by its recovery design. Use a representative production cycle for the estimate. A quiet commissioning week won't describe a year containing product trials, increased production and engineering investigations that temporarily change how much data the workload creates and retains. Engineering time can outweigh a small infrastructure saving include the effort to build, test, deploy and maintain the application in each location, especially where choosing one option requires custom components that the other option wouldn't need. Count. Duplicated work where it actually exists. A hybrid design can require both local equipment and cloud services with separate testing and operating tasks, so splitting execution doesn't automatically split the total bill neatly between them. Downtime exposure needs careful treatment rather than a dramatic number. Ask Production and Finance which losses follow a specific interruption, distinguishing lost output that can be recovered later from scrap or missed commitments that create an unrecoverable cost. Keep uncertainty visible in that estimate. If the likelihood of an interruption isn't supported by evidence, compare several stated scenarios instead of presenting a precise annual loss that depends on a probability nobody can defend, the shape of demand can change the answer. A steady workload that runs throughout production may use purchased local capacity well, while a large analysis that runs occasionally could leave expensive local resources idle between jobs, cloud capacity can suit those occasional peaks. Where the selected service supports scaling or stopping resources, you can match provisioned compute more closely to the analysis window provided the application and its dependencies support that operating pattern. Idle spending still needs active control. A temporary analysis environment can keep generating charges after the engineer finishes, and stopping compute doesn't necessarily remove storage or other services that remain provisioned alongside it afterward. Local capacity has its own waste pattern. Buying enough equipment for an exceptional peak can leave resources unused during normal production, so test whether that peak truly needs immediate execution before sizing the permanent installation around it. Put a range beside the preferred option. Show how its cost changes with production volume, retention and service demand. Then identify the assumption most likely to reverse the decision as those conditions change over time. Price should choose between options that meet the operating requirements. Once those requirements and costs support a placement, we can select the tools to run and manage it without asking a preferred platform to justify a decision we've already funded. Once you've chosen local execution, another question remains how will the central team keep track of that infrastructure and manage approved changes across sites without treating every plant as a separate project? That's where Azure Arc can fit. Azure arc extends Azure based management to supported infrastructure outside Azure, Depending on the resource and service involved. That can include physical or virtual servers and Kubernetes clusters running in your plant or another environment. The word management needs a clear boundary here. Connecting a plant server to Azure Arc doesn't relocate its application into Azure, and it doesn't make Azure the route through which every production transaction must pass. I separate management activity from workload execution. The management plane handles tasks such as registering resources, checking their reported configuration, and coordinating supported administrative actions while the workload continues executing on its assigned infrastructure. Consider our packaging Plants shared server. An authorized administrator could use its Arc resource in Azure to identify the machine and organize it alongside supported resources at other sites, without changing where its applications process their inputs. That gives the central team a consistent inventory. Resource. Names, tags, and grouping can help connect an installation to its site and responsible team, provided someone maintains that information when ownership or equipment changes, inventory still needs evidence of freshness. A resource visible in Azure tells you that it has a registered representation there, but it's displayed information may not describe current conditions if the management connection hasn't reported recently. Policy adds another management function for supported resource types and configurations. Azure policy and related capabilities can help assess specified requirements with enforcement or remediation, depending on the particular policy and services you deploy. Assessment isn't the same as correction. A finding that a server doesn't meet a requirement can inform an administrator. While changing that server requires a permitted mechanism and an operating procedure appropriate to production. Deployment also depends on the resource type with supported arc enabled Kubernetes configurations. GitOps based management can reconcile declared configuration with a cluster, but that capability shouldn't become a blanket claim about deploying anything to every arc connected machine. GitOps means keeping the intended configuration in a version controlled repository. Software in the cluster retrieves that configuration and works toward the declared state, subject to its permissions, connectivity, and the behavior of the deployed components. That distinction affects how you approve changes. Publishing a configuration can initiate work on infrastructure supporting production, so repository access and deployment permissions need the same care. You'd give another administrative route into the plant. Arc doesn't replace the change approval process. Your team still decides which changes may reach production when they're permitted, and what evidence confirms that the resulting installation matches the approved version, rather than merely accepting a successful management action. Now examine what happens without the management connection. An application already running on a local server doesn't necessarily stop because its Arc agent can't contact Azure, but that observation can't establish disconnected behavior for every Arc associated service, check each capability separately. The server agent, a cluster extension, a monitoring component, and a service deployed onto that infrastructure can have different connection requirements, reporting behavior, and supported periods without external access. Separate continued execution from new administrative work. Existing software may keep operating, while a new deployment, configuration retrieval, or remote management action remains unavailable, and the exact result depends on which components the proposed action requires recovery can expose a different dependency. A running installation might tolerate disconnection, while rebuilding that installation requires access to a package source or management endpoint, so verify the supported recovery path as well as normal operation. Use current documentation for the actual deployment, confirm supported versions, required endpoints, and any stated connectivity conditions for each selected Arc service. Then test the behavior rather than extending one component's result to the entire installation. Record what the administrator can no longer observe. If cloud reporting pauses, the central team needs to distinguish an unavailable management connection from a confirmed workload failure without treating an old, healthy status as evidence of present operation, Arc belongs in the management decision, then it can bring supported local infrastructure into Azure based oversight. While the production design determines whether that infrastructure can deliver its workload independently of the available management functions, managing the host leaves another task unresolved. We still need to choose how industrial information enters the local environment and reaches its permitted destinations because infrastructure oversight and industrial data movement carry different responsibilities. The next placement choice concerns the services carrying industrial data. In our packaging plant. That means receiving equipment readings, making them available to local applications, and directing selected records toward destinations that engineers can use. Azure IoT operations fits into that part of the system. It's a set of industrial data services deployed on supported Azure Arc enabled Kubernetes infrastructure with local messaging, connectivity, and data flows configured for the installation. The deployment requirement deserves attention before the protocol discussion. You aren't installing a small desktop utility onto whichever spare computer happens to sit near the line. You're introducing services that depend on a supported Kubernetes environment. Kubernetes manages applications packaged in containers. It schedules those applications onto available computing resources and works to maintain their declared operating state within the capacity and configuration of the cluster you've provided. That creates a platform support requirement. Your chosen installation needs enough compute, memory, and storage for its services and expected traffic, together with people who can diagnose problems in the underlying cluster. Choose the footprint from the supported deployment options. Check Microsoft's current requirements for the Kubernetes distribution infrastructure and component versions you intend to use. Because support for one configuration doesn't establish support for another. For the data journey, begin with an equipment reading. Suppose the packaging machine exposes ceiling temperatures through an OPC UA server, and a local application needs those readings without establishing its own separate connection to that server. OPC. UA means open platform communications unified architecture. It's an industrial communication standard through which software can access equipment information, including values and their associated descriptions, using the capabilities exposed by the particular server. Azure IoT operations includes connectivity for OPC, UA sources you configure, which supported source to connect to and which information to collect. Rather than expect the platform to discover the production relevance of every exposed value, the connection still needs a deliberate configuration. Endpoint settings, certificates and the selection of information to collect must match the equipment server with compatibility verified against the server and connector versions in use. Collected readings can enter the local messaging service. Azure IoT operations includes an Mqtt broker, which receives published messages and distributes them to authorized subscribers according to their subscriptions and the broker's configuration. Mqtt is a publish and subscribe messaging protocol. Its longer name message queuing, telemetry transport matters less here than its role. Senders publish messages under named topics and receivers subscribe to the topics they need. The broker separates publishers from individual receivers. A temperature publisher doesn't need a separate connection to every consuming application, although those applications still need an agreed topic structure and message format to interpret its output. A topic gives the message a routing name. For example, the packaging lines. Temperature readings can use a defined topic that an authorized local consumer subscribes to, without exposing every other message handled by the broker. Messaging and processing perform different jobs. The broker handles message exchange. While configured, data flows can perform supported transformations and move data between selected sources and destinations according to the flow you've deployed. A flow might select fields and reshape a message that lets you prepare a suitable record locally before sending it onward, provided the required processing falls within the supported data flow operations for that deployment. Keep the processing claim specific. A configurable transformation that converts or selects fields doesn't automatically run an arbitrary industrial application, so verify the supported operations before assigning a calculation to that part of the system. Destinations need the same check. Depending on the supported connector and configuration, a flow can send data to services such as Azure Event hubs or storage in Azure Data Lake Storage using the required access settings. Work backward from the intended receiving service. Confirm its supported connection method, expected format, and authentication requirements. Rather than assume that any Azure destination accepts the same flow configuration or interprets the incoming records identically, a local consumer can receive messages through the broker two that gives the plant a way to distribute collected information within the site, while a separately configured flow handles the records intended for a remote destination. The result is a defined industrial data path. You can identify where collection begins, where messages circulate locally, and where configured processing sends them. But that path still needs integration with the applications responsible for using those records. A delivered message doesn't settle who owns the production decision. When that message reaches an application, someone still needs to define what the application may conclude from it and which manufacturing rules govern its response. I'd establish those responsibilities before accepting the integrated system. Otherwise, each supplier can demonstrate that its component works. While the plant still lacks an accountable owner for the behavior that connects those components into a production service. Microsoft supplies capabilities with documented technical boundaries. Your acceptance criteria need to connect those capabilities to the intended manufacturing task without treating a supported connection as proof that the whole task now meets production requirements. Consider a request to start packaging a different product. The infrastructure can carry that request successfully without establishing whether the required material is available, whether the recipe is approved, or whether the equipment supports that product. Those answers come from manufacturing responsibilities, the business system, execution system, recipe management process, and equipment engineering. Each supply part of the authority needed to determine whether that production change is permitted at this plant. Keep those authorities explicit in the integration agreement. If a source system supplies a recipe revision, the receiving application needs to know whether that revision is merely saved, approved for testing, or released for production use. A platform can't decide that distinction for your organization. The people responsible for the process must define which status permits which use. Then ensure the integration preserves that distinction. Wherever the information travels between applications, your team owns the connections between those meanings. That includes deciding how an equipment identifier becomes an application reference, who approves that mapping, and how a changed mapping reaches the applications that depend on it. Treat that work as a maintained engineering deliverable. An asset mapping buried inside a supplier's installation script becomes difficult to inspect or correct when the equipment changes, and nobody remembers which project originally created the association. 01:09:12 Speaker: Data. Contracts need acceptance tests, not just written descriptions. Send examples that include missing fields, unfamiliar product identifiers, and revisions the receiver doesn't support. Then confirm that the receiver handles each case according to the agreed contract, failure behavior needs the same shared agreement. The organization must decide which team detects an unusable handoff, which team reports its production impact, and who has authority to approve the next operating step when the normal exchange fails. Ownership shouldn't stop at a supplier boundary if two components disagree about an order's state. Appoint someone to coordinate resolution rather than asking the shift supervisor to determine which vendor's interpretation should govern the next run. Specialized manufacturing technology has a different responsibility again. An industrial vision supplier might provide the inspection methods and tools needed to assess a difficult surface. While your team remains responsible for validating performance against the products and defects covered by the intended use. A general data platform doesn't replace that assessment. It can support the surrounding information work, but by choosing lighting, establishing acceptable inspection, performance and handling. Uncertain classifications require expertise in the actual inspection problem being solved. Scheduling needs its own specialist reasoning. A production optimization tool can evaluate schedules against modeled constraints, but the plant must supply credible resource capabilities and operating rules before the resulting schedule deserves consideration for execution. Simulation also depends on an accepted manufacturing model. Software can calculate how the modeled process behaves under proposed conditions, while process engineers determine whether those conditions and assumptions represent the factory closely enough for the decision. Validated control remains a separate engineering responsibility. A cloud integration provider shouldn't inherit responsibility for equipment behavior by accident, and a machine supplier shouldn't silently become responsible for every external application connected to its equipment. Bring these responsibilities into procurement and commissioning. Ask each supplier to state its supported interfaces, required inputs, exclusions and diagnostic obligations. Then assign the remaining integration work to a team with the skills and authority to complete it. The gaps matter more than the product count. You can buy capable infrastructure messaging, inspection and manufacturing software, yet still miss the engineering work that makes their combined behavior acceptable to the people running production. Every shift that gives local first design a practical starting point. We can assemble the services around named responsibilities with a defined production path inside the plant and supporting services connected where their role permits, rather than expecting one supplier to own the factory. By implication, let's give those responsibilities a concrete deployment for our hypothetical packaging line. The first pattern places the inspection decision beside production, and uses Azure to examine what those decisions reveal across completed runs. Call it local execution. With cloud analysis, the local installation earns its place by meeting the inspection response budget, while the remote services earn theirs. By supporting questions that extend beyond the pack currently passing, the camera commissioned this pattern around a complete production transaction. During acceptance, the team needs to demonstrate that a captured image produces an inspection result and reaches the approved equipment interface within the budget established for the supported operating conditions. Keep the acceptance evidence tied to the installed version. That means identifying the application accepted model, equipment interface and configuration used during the test, so a later software change doesn't quietly inherit approval from a different installation. The local application then has a precise responsibility. It evaluates the pack and submits the permitted result through the agreed interface, while the receiving control logic determines whether that result can enter the machine sequence. An exchange needs a clear completion point. The application should distinguish a request it has sent from one the equipment interface has accepted using the acknowledgement behaviour agreed with the controls team for this installation. That distinction helps the people commissioning the line. They can verify the hand-off at both ends rather than accept an application log stating request sent as proof that the intended pack received the required handling. The analysis path begins from the resulting production record alongside selected evidence that record can carry the inspection outcome and its manufacturing context to what Azure, without turning successful remote analysis into a prerequisite for completing the local inspection. Give that separation an explicit acceptance criterion an engineer opening a report, refreshing a data set, or running a historical query must not introduce a new weight into the local sequence responsible for inspecting the next pack. Microsoft Fabric can support the broader analytical work. For example, a team could use a fabric lakehouse to bring inspection records together with production data, then prepare information for engineers to explore through power BI. The useful question comes before the report. Instead of asking only how many packs failed inspection. An engineer might compare where failures occur within production runs, and whether a particular product revision changes that pattern. That comparison needs more than the inspection outcome. Joining the outcome to the relevant execution records lets the engineer distinguish a change in the product mix from a change in inspection performance before proposing work on the line. Selected images can support that investigation. A report might identify the production interval needing attention, while the approved evidence location supplies the associated images for a quality engineer to examine. Under the established access rules, fabric doesn't need to host the immediate inspection calculation. Its role in this pattern is to help people work across accumulated production information, with the ingestion and analytical design chosen for that purpose, rather than for machine cycle timing. You can now test the separation through normal business activity. Ask an analyst to run a demanding query while the line continues inspecting. Then confirm that remote analytical demand doesn't consume resources reserved for the local production path. Report access deserves a separate check. If power BI becomes unavailable, the supervisor should lose the analytical view covered by that service. Rather than discover that the same report supplies a value required for every inspection. The reverse check matters just as much. When inspection stops producing new records, the analytical view needs to identify the age of its latest information, so a healthy reporting service doesn't imply healthy inspection at the line. Approval should name both outcomes. Production accepts the demonstrated local inspection behaviour, while engineering accepts the availability and usefulness of the historical information, with neither acceptance standing in for the other team's requirements. This pattern also limits the scope of a reporting change. The analytics team can revise a comparison or add a view without modifying the accepted inspection path, provided it preserves the agreed separation and stays within the data services permitted. Use more lines. Introduce a different placement question once several local installations need the same supporting services, the plant has to decide whether sharing those services reduces operating work enough to justify making multiple lines depend on them. Sharing plant services changes which failures can spread between lines in our packaging plant. The second pattern puts collection, temporary storage and selected applications on site infrastructure that several lines use while keeping their immediate inspection decisions separate. Choose what to share by examining the consumers. A plant collection service could receive production events from several lines, while a shared context service supplies approved asset and product references to applications that need consistent local information that can reduce the number of installations to maintain, instead of maintaining a separate reference service beside every line. The plant team operates a common service with enough capacity for its agreed consumers and their supported demand. Sharing also concentrates responsibility for capacity. If one line starts publishing much larger records, its increased demand shouldn't consume the storage or processing allowance that another line needs to deliver its approved service. Set resource limits around the shared workloads, reserve capacity where necessary, and measure consumption by source so the team can identify which producer causes pressure before several applications begin reporting apparently unrelated faults. Older equipment needs a route into this arrangement. A legacy controller might expose useful production information through a vendor specific interface, requiring a suitable gateway between that equipment and the plant collection service, rather than a direct connection. Keep that gateways task narrow and supported. Confirm which values it reads, how often it requests them, and whether those requests impose additional work on a controller already responsible for running the equipment collection must respect the existing network boundaries. The approved route might carry selected records from a line gateway toward the plant service, without granting that central service permission to browse or write across every connected equipment network. A shared service shouldn't require a flattened plant network where different lines occupy separate zones, maintain those boundaries and arrange the permitted exchanges individually, even if the receiving application runs on one common installation. Placement now creates a larger failure consequence losing a dedicated line service affects its assigned line, while losing shared storage could interrupt evidence collection across several lines that otherwise remain capable of producing PACs. Assess that consequence before choosing the recovery design. Some shared applications can tolerate an interruption, while others need alternate capacity. Because several production areas depend on their continued availability during the same operating period, redundancy has to cover the actual dependency. Two application instances don't protect the service if both depend on a single storage system, network switch or power source whose failure removes their ability to serve the plant. Separate hosts can still share a fault. Ask where their power network paths and stored state converge, then identify which single failures the proposed arrangement actually survives. Rather than counting running copies of the application. Failover also needs a clear authority for accepting writes. If both copies believe they own the same, changing records after a network split recovery can produce conflicting state. Instead of the dependable service the plant expected user supported availability design for the chosen platform, verify how it prevents conflicting updates and what it does when it can't determine which instance should remain active, including any interruption required to protect stored information. Storage recovery needs a practical rehearsal. Restore the shared service into a controlled environment, then check that its records configuration and references agree sufficiently for the consuming applications to resume their permitted work. Without guessing. Restoring files isn't the final acceptance check. An application may start successfully, while its restored context refers to an earlier equipment configuration, leaving several lines exchanging records against mappings that no longer describe the installed plant. Test the local network alongside the application recovery. Disconnect an approved test path and verify which lines lose service, whether the alternate path actually carries their traffic, and whether recovery preserves the intended network restrictions. Include simultaneous demand in that exercise. When several line gateways reconnect together, the shared service must accommodate their return without letting one busy producer prevent other lines from reestablishing their agreed exchanges. The decision rests on the service the plant can sustain. Shared infrastructure earns its place when the reduction in separate installations justifies its wider failure impact, backed by demonstrated capacity and recovery, rather than unused ports on an existing server. Some work won't justify that site level commitment once you've identified which services genuinely need shared local capacity. You can assess the remaining workloads for remote execution based on how long their consumers can wait for a useful result. A maintenance recommendation can remain useful without arriving during the machine cycle. That makes it a candidate for our third pattern processing in Azure, with a defined local response. When the remote result isn't available, the fallback needs a narrower purpose than the cloud service. It preserves an approved way of working during interruption, rather than promising that a small local application can reproduce every calculation performed by the remote service. Take a hypothetical maintenance review for the packaging lines. Drive equipment engineers compare recent condition measurements with historical behavior and similar equipment elsewhere, then issue advice about which assets deserve attention during the next maintenance window. That review can tolerate a defined wait. Its deadline comes from when the maintenance team must choose its work, so remote processing remains a reasonable option if the result arrives before that decision. Historical analysis and comparisons across plants follow similar reasoning. There, consumers can often wait for a completed calculation provided the application states which production period it covers and doesn't present incomplete analysis as a finished assessment. Azure functions can handle suitable event driven parts of this arrangement. For example, an arriving condition summary could trigger a function that checks required fields, performs a bounded calculation, and writes a result for the maintenance application. Choose the execution plan around that particular task function. Timeout limits available resources and scaling behaviour depend on the hosting option and configuration, so verify them before assigning a large historical calculation to one invocation. Delivery behaviour also depends on the trigger. Some triggers support retries under specified conditions, which means the function must handle another attempt without creating contradictory recommendations or treating repeated input as new evidence each time. A successful invocation doesn't necessarily complete the maintenance review. If the function delegates a longer calculation elsewhere, the application needs a separate completed result status before anyone presents the resulting advice as ready for use. Now, suppose Azure becomes unreachable before the next review. The local application could retain the most recent approved maintenance recommendation together with its source period, approval status and the conditions under which maintenance may still use it. That copy supports continuity within a defined limit. It lets the team consult advice already accepted for the relevant equipment, without pretending that the advice incorporates measurements or operating changes that occurred after its calculation. Another fallback could use a bounded local rule. For example, an engineering approved rule might flag a measurement for manual review when it crosses a specified limit without attempting the broader comparison performed in Azure. Keep the rules authority narrow. A prompt to inspect an asset doesn't automatically authorise continued operation. Postpone an existing maintenance requirement, or cancel a restriction that the responsible engineer has already placed on the equipment. The operator needs to know which service they're receiving, display or communicate whether the advice comes from a current remote assessment, an earlier approved result or the limited local rule using terms the maintenance team understands. Freshness requires more than a timestamp. Define the maximum acceptable age and the changes that invalidate the advice, because replacing a bearing can make yesterday's assessment unsuitable, even if its age remains within the ordinary limit. Those invalidation conditions belong in the receiving application. If the relevant equipment configuration changes, the application should withdraw advice that no longer applies. Rather than leave the operator to infer that limitation from a maintenance record elsewhere. Some expired advice should become unavailable for action, where using an old recommendation could create an unacceptable decision, block its operational use and direct the person to the approved manual review procedure instead. Retain the distinction between history and permission. An older assessment can remain available for investigation while clearly carrying no authority for today's maintenance decision, so access to the record does not imply approval to act on it. Restoring connectivity shouldn't instantly restore confidence in every recommendation. The remote service needs, the relevant current inputs and a completed assessment before the local application replaces its fallback state with newly accepted advice for that equipment test the handover at the maintenance decision itself. Ask whether the person choosing the work can identify what remains approved, what needs review, and which action must wait until a suitable assessment becomes available. Industrial AI adds another placement choice. Within this pattern, we need to distinguish the work that develops a predictive model from the work that applies an accepted model to incoming production data. Because those jobs can justify different locations. Training changes. The model inference uses a particular model version. That separation lets you choose where development runs without committing production to the same location, hardware or release schedule used by the engineers developing it during training. Software learns patterns from historical examples. For our inspection task, engineers use labeled images to adjust the model, then assess its performance against separate examples that weren't used to fit those learned patterns. Azure can provide compute for that development work. If approved, training data already resides there. Engineers can provision suitable resources for experiments without installing equivalent development capacity at every plant that will eventually use the model Data access can change that choice. If required, images must remain at the site or transferring them would delay development beyond its useful window. Local training may deserve consideration despite the attraction of remote compute. Choose resources around the experiment, not the label. AI some training jobs need graphics processing units or GPUs, while others fit less costly hardware depending on the model, data set and time available for completing the work. Production inference presents a different resource profile. Once engineers have accepted a model, applying it to incoming images can require much less compute than training, although the actual requirements still needs measurement on the intended production hardware. That difference makes an edge deployment practical in some cases. Response deadlines, image transfer volume, and required operation without external connectivity can justify local inference, even when development depends on a much larger computing environment in Azure. Acceptance comes before deployment to the line. A new model needs assessment against the product's defect types and operating conditions covered by its intended use with particular attention to defects. It misses an acceptable packs it rejects an overall accuracy score, won't resolve those trade offs. Quality and process owners need results broken down in ways that expose unacceptable failure patterns, rather than approving a model because its average performance exceeds an earlier version, use a controlled assessment data set and preserve its identity. If engineers repeatedly tune the model against the same assessment examples, they risk learning those examples, indirectly, leaving the reported result less representative of unfamiliar production input. The accepted release includes more than the model file record, the image preparation decision thresholds, required software and applicable product conditions alongside the model version, because changing any of those can change the result produced from an identical image. Production hardware needs its own compatibility test. A model developed with one software library or accelerator may require conversion for another device, and that conversion can affect supported operations, numerical behavior, memory demand, or execution time. 01:26:57 Speaker: Compression of the model needs assessment to. Quantization, which represents calculations with reduced numerical precision, can reduce resource demands, but engineers must check whether the converted model still meets the inspection acceptance requirements on its target hardware. Test with sustained production demand, not a single image memory use, accelerator availability and heat can affect the installation over a run, so verify the accepted model under the conditions that the deployed computer must actually support. Release changes through a controlled production procedure before activating a new version. Confirm that the target installation has the complete accepted package and that its reported identity lets engineers trace subsequent results to that release. Keep a tested rollback package available. If the new version produces unacceptable behavior, the authorized team needs a way to restore the previous accepted release, including its compatible settings and software, rather than merely selecting an older file. Monitoring then asks whether the accepted behavior still holds. Drift means the production input or its relationship to the expected result has changed, perhaps because packaging, material, lighting or the appearance of a defect changes over time. A changed input distribution deserves investigation, not automatic retraining. Compare it with reviewed production examples and quality findings because a statistical change can be harmless, while a missed defect may demand action without producing a clear distribution shift. Assign ownership for that review and its operating response. The team needs to know when evidence calls for model reassessment, when another part of inspection needs attention and who can restrict use of the affected release. Local inference can now return a traceable prediction when that prediction supports a wider production. Decision placement must also account for the information and constraints needed to turn it into an accepted course of action. A prediction about equipment condition can change which orders production can finish. Planning has a wider reach because moving work away from one resource changes the demands placed on other resources and the commitments attached to that work. Scheduling needs more than a machine's availability. Advanced planning and scheduling, or APS, builds plans and schedules around production constraints, including the capacity available to perform the required operations within the time allowed. Consider a planning decision in a hypothetical packaging plant. One packaging line becomes unavailable and the planner needs to assess whether moving its remaining orders to another line would protect deliveries without disrupting work already assigned there. An available line isn't necessarily a suitable substitute. Its tooling might support only certain pack sizes, and moving an order could require a changeover that consumes capacity. The planner hoped to use for production sequence can affect the answer to running compatible products together might reduce change over time, while placing an urgent order first could protect one delivery at the expense of several orders that follow it. The scheduling system needs those rules represented explicitly. Its result depends on the constraints and priorities supplied to it, so the planning team must decide which limits are fixed and which preferences can be traded against each other. ERP and Ms. contribute different inputs to that calculation. ERP can supply order requirements and planning data, while Ms. contributes execution context. That helps establish what remains to be completed and which resources currently support that work. Neither input alone establishes a feasible schedule. A business record can show an outstanding quantity, while production has already completed part of it, leaving the calculation to reserve time for work that no longer needs doing. Planning therefore needs a defined starting state. Before launching a calculation, establish which execution updates it includes, which orders remain open and how it accounts for work already underway that the planner can't simply move elsewhere. That starting state needs a time boundary. If the calculation runs while production continues, its output should identify the state it used, allowing the planner to check whether subsequent events invalidate the proposed changes. Azure can suit calculations spanning several lines or plants. A planning application could compare alternative allocations using remote compute, provided its deployment data access and decision windows support. Completing those comparisons before the planner needs to act. Compute speed doesn't settle placement by itself. A fast calculation based on yesterday's remaining quantities can produce a less usable schedule than a slower calculation that includes the production state needed for today's decision. Measure the age of each important input, material availability and equipment status may update at different rates, so one recent timestamp on the planning data set shouldn't imply that every constraint reflects conditions at that same moment. The decision window also includes human review. If the planner needs an accepted schedule before the next dispatch period, leave enough time to inspect the proposed changes rather than spending the entire window searching for a better mathematical result. Define what makes a return schedule acceptable. The planning owner should establish whether a feasible result within the available time is sufficient, and how to handle a calculation that finishes without meeting the required planning conditions. This connection then becomes a question of execution continuity. The plant needs local access to its last accepted schedule, including its revision and applicable scope, so the shift doesn't depend on reopening a remote planning session to find approved work. An accepted schedule still has limits during an outage. If equipment fails or material becomes unavailable, the shift needs an agreed method for recording changes and identifying which parts of that schedule no longer remain feasible. give local changes and named authority and permitted scope. A supervisor might be authorized to resequence ready orders on one line. While moving work between plants remains a planning decision that requires information unavailable at the disconnected site. Preserve those local decisions for later reconciliation. When remote planning resumes, its starting state must include work actually completed and changes already accepted locally. Rather than calculate from the schedule issued before the interruption. The output now carries an operational commitment. Once a planner accepts a revised schedule, the next question concerns how its instructions reach the plant and become permitted execution requests without treating a calculated plan as direct authority over equipment. Accepting a schedule doesn't authorize every instruction it might generate. The connection that delivers production records to Azure should have no automatic right to send instructions back into equipment, even when both exchanges involve the same application. Separate the reporting path from command authority. A service permitted to read line status needs a distinct, explicitly approved permission before it can submit a request that changes what production does next. Define permitted requests as specific operations stage. This approved job for operator review gives the receiver a bounded task, whereas write this value to this address exposes a much broader capability with less manufacturing, meaning the request should carry enough information for a decision, include its intended recipient requested operation, relevant production revision, issuing identity, and a unique request identifier that remains unchanged if the sender repeats the delivery permission checks belong at the receiving boundary. Two A request can arrive through an authenticated connection, yet still ask for an operation that its issuing service isn't authorized to perform for that particular line or production area. Check the request against its intended scope. An identity allowed to stage work on one packaging line shouldn't gain permission to release work elsewhere, merely because both lines receive instructions through the same plant application. Time limits need to travel with the instruction. A request should state when it expires, and the receiver needs a sufficiently trustworthy time reference to reject instructions whose permitted window has passed before they reach execution. An old instruction can become wrong without changing its contents. Suppose a planner withdraws an order. While its earliest staging request waits for delivery, the receiver must check the applicable order revision rather than accept arrival as proof of continued approval. Check current machine and production state before acceptance for a job staging request. That could include whether the line remains assigned to the specified order, and whether an intervening local decision has changed what may happen next. Rejection needs an explicit result. Return a reason the sending application can interpret, such as expired request or conflicting production revision. Instead of leaving the sender to guess whether another delivery attempt might succeed. Repeated delivery needs a different response from repeated action. If a sender loses the acknowledgment, it may transmit the same request again, and the receiver should recognize that identifier rather than create a second physical operation. Keep a durable record of accepted request identifiers. That record must survive. The interruptions covered by the design, or restarting the receiving application could erase its memory and let a repeated instruction appear new again. The identifier also needs a consistent payload. If a sender reuses an existing identifier with different instructions, reject that conflict rather than let an apparently familiar request silently change what the receiver previously accepted. Physical completion can still leave an uncertain outcome if equipment performs an action, but confirmation disappears before the receiving application records it. Repeating the action may be unacceptable, even though the software can't prove completion. Provide a way to resolve that uncertainty. The receiver may need to query an equipment transaction record or require an authorized local check, with further execution held until the actual outcome becomes clear enough to proceed. Distinguish acceptance from completion in the returned status. Accepted for review. Execution started and completed. Describe different commitments so the remote application shouldn't treat the first acknowledgement as confirmation that production has carried out the instruction. Local authority needs a named owner in our packaging plant. The agreed procedure might let the shift supervisor approve a staged job while the receiving service checks that the approval still applies before releasing the permitted request. Record the decision alongside the instruction. The audit trail should connect the original request, its issuing identity, local checks operator approval where required, and final outcome without relying on separate teams to reconstruct the relationship later. Conflicting local decisions must remain visible if the supervisor declines a request because the line has been reassigned, return that outcome and require a newly authorized instruction instead of letting automated retrieves override the refusal. This gives clout to plant communication. A defined contract. The remote application proposes a permitted operation, and the plant accepts, rejects or holds it according to current authority and state, with uncertainty treated as a condition requiring resolution. Those promises now need evidence. Before relying on this path in production, the team needs to demonstrate that interrupted exchanges and repeated requests preserve the intended physical outcome, not merely that messages eventually reach their destination. Turn each operating promise into a drill with an observable production outcome. Start from the workload placement record, choose the requirement being challenged, and write down what would count as a pass before anyone introduces the fault. Keep the first exercises away from live production. Use a representative test, installation, simulation, or approved maintenance window, with the responsible engineers agreeing which faults can be introduced without exposing people, equipment or released product to harm. Assign someone to control the exercise and stop it if necessary. Give observers specific responsibilities, including watching the inspection sequence, checking saved evidence and recording what the shift team actually experiences, rather than relying entirely on application logs. Begin with loss of the external connection. Cut the approved test route while inspection is active. Then attempt the operations covered by the disconnected operating plan, including a restart. If continued recovery without that route forms part of the requirement. Judge the drill against inspected packs, not server uptime. Confirm whether every test pack receives the required handling and whether any unavailable result produces the approved degraded response, with the affected items identifiable afterward. A failed node challenges a different assumption stop one designated computing node through an approved method, then observe whether its workloads recover on the intended infrastructure, and whether that recovery stays within the interruption permitted by the records. Watch for partial recovery during that exercise. A replacement instance might accept new traffic while still lacking the configuration or stored state needed to process it correctly, so verify its output before declaring the service restored. Next, exhaust the buffers assigned space in the test environment. Feed controlled records until the configured limits take effect, then check whether required evidence remains protected and whether the resulting production restriction appears where the shift can act on it. Trace the affected test items through the records. The team should be able to distinguish evidence preserved successfully from evidence never accepted, without searching unrelated log files. To work out which production needs a quality review, credential failure needs a controlled test case to use a test credential with a planned expiry allow it to expire during the exercise and confirm that the application follows the approved access response rather than silently dropping work. Then make a downstream server slow without making it completely unavailable. Introduce a controlled response delay and observe whether waiting requests consume resources until another workload suffers, or whether the designed limits contain the disruption that distinction can decide. Placement. A service that survives a clean disconnection might fail during intermittent responses, so test the behavior production could encounter. Rather than choosing only faults that produce simple, immediate error messages. Keep the recovery phase under observation. Once the fault is removed, measure whether the backlog clears within its target. While current inspection continues to meet its requirements, instead of ending the exercise at the first successful connection. Use a known set of test records for reconciliation. Compare what entered the system with what reached the accepted destination, identify missing or repeated records, and confirm that repeated delivery hasn't created additional production outcomes. Check configuration consistency before closing the drill. Compare the active versions and settings on recovered components with the approved release, including any instance that restarted while configuration services remained unavailable or while an update was partly complete, give degraded operation its own pass criteria. Observers should confirm that the application permits only the work approved for that condition communicates restrictions correctly and blocks any next step that would exceed the accepted operating boundary. Record. How long each condition lasts include the interval before detection, the time needed for the authorized response, and the period until verified restoration. Because the workload record may constrain more than the application's own restart duration, a failed drill should change an engineering decision if the inspection path stalls because shared storage stops responding, identify the dependency responsible and revise the design or the claimed operating capability before repeating the same acceptance test. Don't quietly relax the passed criteria afterward. Any proposed change to the requirement needs approval from its production owner, with the revised consequence understood. Rather than treating a disappointing test result as permission to accept greater exposure. Keep the evidence attached to the placement record. The location now has a tested operating envelope, and any unresolved failure tells you exactly which assumption still prevents that placement from earning production approval. The drill results let us make a plant wide commitment. Instead of approving isolated installations, we can now decide which production capabilities the site will support together and which dependencies it accepts between them. I'd review the packaging plant by production area for each area, ask whether its approved workloads still meet their requirements when the neighbouring area is busy, disconnected or undergoing maintenance. Using the evidence collected during testing, that review can reveal incompatible assumptions between otherwise acceptable designs. One team may have approved inspection on the assumption that plant storage always responds, while the storage team approved maintenance interruptions on the assumption that inspection never waits for storage, resolve that conflict before approving the combined installation, both teams need the same operating agreement, including which servers may become unavailable and what production can still do during the interruption without exceeding its accepted limits. For inspection. Approval should name the local boundary precisely. That might cover one station and its equipment interface, with safety and motion remaining under their designed control systems, rather than becoming responsibilities of the shared industrial data platform. Then examine the services that cross production areas. Plant buffering and context services need an approved consumer list because adding another line changes their demand and can increase how much production depends on one installation. Make new consumers and engineering change, not an informal connection. A project shouldn't inherit permission to use a shared service, simply because it can reach the endpoint, and its first few messages appear to arrive successfully. The Azure workloads need equally clear acceptance boundaries. Historical analysis and fleet learning can serve several plants, while suitable planning work can run remotely only within the freshness and decision windows approved by the people using its output. Remote sharing doesn't erase each site's operating constraints. If one plant can wait longer for a planning result than another, the common service needs to respect both requirements or explicitly exclude the work it can't support. Now review the placements against each other. A choice that looks economical for one workload can consume bandwidth, storage, or support capacity already committed elsewhere. So the plant needs to evaluate the combined demand rather than approve every project independently. Use production priorities to settle those conflicts. If two workloads compete during recovery, their owners need an agreed allocation before deployment, not a contest decided by whichever application opens more connections or retrieves more aggressively. Ownership needs the same cross-check. Every dependency shared between teams should have someone accountable for resolving disagreement, including permission to involve the production authority when a technical repair alone won't restore the promised operating capability. I'd also record what would move a workload later a changed deadline, different data policy or loss of support coverage can justify a new placement, even when the application itself hasn't gained a single new function that keeps location from becoming an inherited rule. We run this locally should remain a decision supported by current requirements and evidence, rather than a permanent answer preserved because moving it would reopen an uncomfortable discussion. Before signing off, follow one complete production change. Take an approved next order and check whether the plant can obtain every prerequisite needed to begin it under the disconnected conditions its operating plan claims to support. Look beyond the work already running. A line can complete today's product successfully while lacking something required for tomorrow's first run, so continuity needs to cover the next permitted transition as well as the current cycle. One unresolved prerequisite can limit the whole plant's claim. If the next order still requires an external approval lookup, record that restriction plainly, even when every production computer remains healthy and all current inspection tests pass. Local hardware doesn't guarantee a locally complete production path. A healthy edge server can still leave the next run blocked if one required. Approval lookup or start up check depends on Azure, and nobody has approved an alternative name. That dependency before the outage names it for you. Which workload in your plant would lose its first required capability without Azure access? And what fallback have you actually approved for that exact point of failure?