<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Andrew Davies</title>
    <description>The latest articles on DEV Community by Andrew Davies (@andrew_davies).</description>
    <link>https://dev.to/andrew_davies</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4118395%2F6bc2d683-f67c-4f3e-b308-ee75db50ddc0.png</url>
      <title>DEV Community: Andrew Davies</title>
      <link>https://dev.to/andrew_davies</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/andrew_davies"/>
    <language>en</language>
    <item>
      <title>Your Vision Model Works in the Lab. Here's Why It Breaks on the Factory Floor</title>
      <dc:creator>Andrew Davies</dc:creator>
      <pubDate>Wed, 18 Nov 2026 10:05:46 +0000</pubDate>
      <link>https://dev.to/andrew_davies/your-vision-model-works-in-the-lab-heres-why-it-breaks-on-the-factory-floor-2bm7</link>
      <guid>https://dev.to/andrew_davies/your-vision-model-works-in-the-lab-heres-why-it-breaks-on-the-factory-floor-2bm7</guid>
      <description>&lt;p&gt;&lt;strong&gt;TL;DR&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Most computer vision failures on a production line aren't model failures. They're optics, data, integration, and drift problems.&lt;/li&gt;
&lt;li&gt;Run inference on the edge. Use the cloud for training and fleet-wide analytics.&lt;/li&gt;
&lt;li&gt;A detection only matters if it reaches the PLC and gets recorded in the MES.&lt;/li&gt;
&lt;li&gt;Pilot on a real section of the line. What takes days to fix in a pilot takes months after a full rollout.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;Here's a scenario that plays out more often than it should. A defect-detection model posts great numbers on the validation set, gets installed on a production line, and within a week the operators want it switched off. It flags shiny parts as cracked, misses a defect type nobody photographed, and after maintenance swaps a light fixture, nobody can say whether it's still accurate.&lt;/p&gt;

&lt;p&gt;None of that is really a model problem. It's the engineering around the model.&lt;/p&gt;

&lt;p&gt;The stakes for getting that engineering right keep rising. The World Economic Forum found that manufacturers pairing AI with IoT, cloud, and related technologies outperform their peers by 16% or more, and that 94% of successful industrial transformations combine several technology domains instead of running AI as a standalone experiment. A camera plus a model is never the whole system.&lt;/p&gt;

&lt;p&gt;Below are seven lessons for developers building vision systems that have to survive real factory conditions.&lt;/p&gt;

&lt;h2&gt;
  
  
  First, a quick map of what vision does on a line
&lt;/h2&gt;

&lt;p&gt;The use cases covered in most overviews of &lt;a href="https://yalantis.com/blog/computer-vision-in-manufacturing/" rel="noopener noreferrer"&gt;computer vision for manufacturing&lt;/a&gt; fit into four buckets. Here's how they look from the implementation side:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Use case&lt;/th&gt;
&lt;th&gt;What the camera looks for&lt;/th&gt;
&lt;th&gt;What happens on a hit&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Quality inspection&lt;/td&gt;
&lt;td&gt;Scratches, cracks, missing or misaligned components, wrong labels, dimensional drift&lt;/td&gt;
&lt;td&gt;Part is rejected, or routed to a person if confidence is low&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Predictive maintenance&lt;/td&gt;
&lt;td&gt;Abnormal motion, hot spots on thermal cameras, leaks, corrosion, buildup, analog gauge readings&lt;/td&gt;
&lt;td&gt;Alert is correlated with IIoT sensor data and maintenance history&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Worker safety&lt;/td&gt;
&lt;td&gt;Missing PPE, people in restricted zones or too close to machinery, forklift and AGV conflicts, unauthorized access&lt;/td&gt;
&lt;td&gt;Alarm, supervisor notification, or nearby equipment slows down&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Process and robotics&lt;/td&gt;
&lt;td&gt;Throughput drops, stalled units, product classes for sorting, part positions for pick-and-place&lt;/td&gt;
&lt;td&gt;Bottleneck gets flagged, item gets routed, robot adjusts its motion&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Different rows, very different failure modes. But the lessons below apply to all of them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lesson 1: Fix the light before you fix the model
&lt;/h2&gt;

&lt;p&gt;Factories are hostile to cameras. Reflective metal throws glare, ambient light shifts between day and night shifts, dust settles on housings, and the line itself vibrates. A model trained on clean images will degrade on every one of these, no matter how good its architecture is.&lt;/p&gt;

&lt;p&gt;You can't augment your way out of bad optics. The fix happens upstream: controlled lighting, industrial enclosures, and lens and mounting setups tuned to each line. Stable input is what makes detection stable.&lt;/p&gt;

&lt;p&gt;A real example shows how much this matters. A Tier-1 European automotive supplier was letting 0.8% of defects slip through: micro-fractures in cast aluminum brake components moving at 1.2 m/s. What made the difference wasn't just a better network. It was dedicated lighting, telecentric optics (which keep magnification constant regardless of small changes in part distance, so geometry doesn't distort), and a model trained on that supplier's own defect classes. The system reached 99.7% detection accuracy, let the line run 15% faster, paid back in eight months, and stopped defect escapes to OEM customers entirely.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lesson 2: Your dataset will be short on exactly the images you need
&lt;/h2&gt;

&lt;p&gt;Critical defects are rare by design; that's the whole point of a well-run line. So the classes you care about most are the ones with the fewest examples, and a model trained on a thin dataset will miss the edge cases.&lt;/p&gt;

&lt;p&gt;What works in practice:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Capture training images from the real line, both good and defective units&lt;/li&gt;
&lt;li&gt;Label defect types explicitly, not just pass/fail&lt;/li&gt;
&lt;li&gt;Generate synthetic samples to cover rare defects&lt;/li&gt;
&lt;li&gt;Keep retraining as new defect types show up in production&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Augmentation helps you cover the capture conditions the line will throw at you:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;albumentations&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;

&lt;span class="c1"&gt;# Simulate what actually varies on a line: light, motion, sensor noise, small misplacement&lt;/span&gt;
&lt;span class="n"&gt;line_conditions&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Compose&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;
    &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;RandomBrightnessContrast&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;brightness_limit&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.25&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;contrast_limit&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.25&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.7&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MotionBlur&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;blur_limit&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;GaussNoise&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Rotate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;limit&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;border_mode&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.5&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;augmented&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;line_conditions&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;image&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;image&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"image"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Keep in mind what this does and doesn't do: augmentation widens coverage of conditions, but it won't invent defect types you've never seen. Synthetic defects need to be checked against real samples before you trust them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lesson 3: Decide on the edge, learn in the cloud
&lt;/h2&gt;

&lt;p&gt;A production line can't wait for a network round-trip. When a cracked part passes the camera or someone steps into a danger zone, the response has to happen now. So inference runs on hardware next to the camera: frames are processed on-site in milliseconds, and a flaky uplink can't stall the line. Even constrained devices can handle real-time inference with TinyML-style approaches.&lt;/p&gt;

&lt;p&gt;The cloud still earns its place, just for different work: training on large datasets, storing history, comparing trends across plants, and running deeper analysis on sampled frames where speed doesn't matter.&lt;/p&gt;

&lt;p&gt;If your architecture diagram puts the reject decision on the far side of a WAN link, redraw it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lesson 4: If it doesn't reach the PLC, it's just a dashboard
&lt;/h2&gt;

&lt;p&gt;A camera on its own only watches. The factory acts through two systems: &lt;strong&gt;PLCs&lt;/strong&gt;, which execute commands like start, stop, and reject, and the &lt;strong&gt;MES&lt;/strong&gt;, which tracks production flow and keeps the records. Your vision system has to talk to both without breaking the logic they already run.&lt;/p&gt;

&lt;p&gt;Here's the shape of that loop:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;enum&lt;/span&gt; &lt;span class="nf"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;Enum&lt;/span&gt;

&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Action&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Enum&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="no"&gt;PASS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"pass"&lt;/span&gt;
    &lt;span class="no"&gt;REVIEW&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"review"&lt;/span&gt;
    &lt;span class="no"&gt;REJECT&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"reject"&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;decide&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;score&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;float&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;reject_at&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;float&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;review_at&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;float&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;Action&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="s2"&gt;"""score = the model's defect confidence for one unit"""&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;score&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="n"&gt;reject_at&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nc"&gt;Action&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;REJECT&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;score&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="n"&gt;review_at&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nc"&gt;Action&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;REVIEW&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nc"&gt;Action&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;PASS&lt;/span&gt;

&lt;span class="n"&gt;action&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;decide&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;pred&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;defect_score&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;reject_at&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.92&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;review_at&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.60&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;action&lt;/span&gt; &lt;span class="k"&gt;is&lt;/span&gt; &lt;span class="nc"&gt;Action&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;REJECT&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;plc&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;write_tag&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"ST03_REJECT"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;        &lt;span class="c1"&gt;# the only tag this node may write&lt;/span&gt;
&lt;span class="k"&gt;elif&lt;/span&gt; &lt;span class="n"&gt;action&lt;/span&gt; &lt;span class="k"&gt;is&lt;/span&gt; &lt;span class="nc"&gt;Action&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;REVIEW&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;review_queue&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;put&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;unit_id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;frame&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;          &lt;span class="c1"&gt;# a person makes the call&lt;/span&gt;
&lt;span class="n"&gt;mes&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log_inspection&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;unit_id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;action&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;pred&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;defect_score&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c1"&gt;# every unit, every time&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;(Illustrative. In real plants the PLC side usually goes through OPC UA or a fieldbus, and thresholds are tuned per station.)&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;One thing worth saying out loud: the moment your vision node can write to a PLC, it's a privileged actor on the OT network. Give it access to exactly the tags it needs, put it in its own network segment, and treat those writes the way you'd treat any other control command.&lt;/p&gt;

&lt;p&gt;The upside is that this rarely means redesigning the line. New hardware is usually limited to cameras, lighting, and edge compute that sit alongside existing controls; occasionally a specific component needs an upgrade to get reliable image quality.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lesson 5: Price your errors before you pick thresholds
&lt;/h2&gt;

&lt;p&gt;A false positive and a false negative don't cost the same. A false positive can stop the line or scrap a good part. A missed defect travels downstream and can cause a much bigger failure later. Which one hurts more depends on the station, so thresholds should be set per station, based on what each error actually costs there.&lt;/p&gt;

&lt;p&gt;This is also why hybrid setups work so well: confident defects get rejected automatically, uncertain ones go to a person. That combination can pay for itself in under a year. And when the system is built well, it can catch up to 90% more defects than manual inspection while raising inspection productivity by as much as 50%.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lesson 6: Treat the model like firmware, not a one-off deliverable
&lt;/h2&gt;

&lt;p&gt;Factory conditions drift. Lighting changes, equipment wears, and new product variants arrive. A model that's accurate today will slowly stop being accurate if nobody's watching.&lt;/p&gt;

&lt;p&gt;So run it like production software:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Monitor accuracy continuously&lt;/strong&gt; and catch drift before it shows up as escapes or false stops&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Review and retrain on a schedule&lt;/strong&gt;, not just when something breaks&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ship updates without stopping the line&lt;/strong&gt;, through &lt;strong&gt;Secure Boot and signed OTA&lt;/strong&gt; pipelines so only verified firmware and model artifacts run on edge devices&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Protect inspection records&lt;/strong&gt; from tampering, since quality data often ends up as audit evidence&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Lesson 7: Pilot on the real line, not in the lab
&lt;/h2&gt;

&lt;p&gt;The lab hides the problems that matter. On a real line section you'll find the reflection that confuses the model, the product variant nobody included in training, and the timing mismatch between camera trigger and conveyor. Fixing those during a pilot takes days. Fixing them after a full rollout takes months.&lt;/p&gt;

&lt;p&gt;A pilot typically takes 8 to 16 weeks from confirmed use case to live testing, longer if legacy integration is complex or defect data is thin. When you scale, expect per-site tuning, because lighting, equipment, and product mix differ between facilities. Give the plant team dashboards for model performance, defect rates, and alerts so they can tell whether the system is doing its job.&lt;/p&gt;

&lt;p&gt;Two more practical notes. Not every problem on the floor is a vision problem, so be honest about that before building anything. And because hardware (cameras, edge compute, installation) is a big share of the budget, starting with a single inspection station is far cheaper than going facility-wide on day one.&lt;/p&gt;

&lt;h2&gt;
  
  
  Beyond inspection
&lt;/h2&gt;

&lt;p&gt;Quality inspection is the usual entry point, but the same engineering applies elsewhere:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Predictive maintenance.&lt;/strong&gt; Weak maintenance strategies can cut productive capacity by 5–20%, and unplanned downtime costs industrial companies around $50 billion a year. Vision becomes useful here when it's combined with IIoT sensors and maintenance logs. Done well, AI-driven predictive maintenance can reduce downtime by 30–50%, extend equipment life by 20–40%, raise asset productivity by up to 20%, and lower maintenance costs by up to 10%.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Safety.&lt;/strong&gt; US businesses spend more than $1 billion a week on non-fatal workplace injuries, and work-related deaths and injuries cost the US $1.2 trillion in 2022. One engineering caveat: here your input data is people. In the EU, footage of identifiable workers is personal data under GDPR, so process on the device, store events instead of raw video where you can, and lock down who can access recordings.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Robotics.&lt;/strong&gt; Better object recognition and semantic segmentation are what let cobots and robotic arms adapt instead of following fixed paths. McKinsey estimates that Industry 4.0 solutions combining AI and advanced automation can lift labor productivity by 15–30%.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Wrapping up
&lt;/h2&gt;

&lt;p&gt;The model is the part everyone demos. Optics, scarce defect data, PLC and MES integration, error costs, drift, and a real-line pilot are the parts that decide whether the system is still running a month later. If you're starting out, defect detection and safety monitoring tend to deliver the clearest, most measurable return.&lt;/p&gt;

&lt;p&gt;Have you shipped computer vision into a production environment? I'd like to hear what broke first. Drop it in the comments.&lt;/p&gt;

</description>
      <category>iot</category>
      <category>computervision</category>
      <category>machinelearning</category>
      <category>python</category>
    </item>
    <item>
      <title>6 IoT Trends for 2026, Translated From Business-Speak Into Developer</title>
      <dc:creator>Andrew Davies</dc:creator>
      <pubDate>Thu, 10 Sep 2026 02:27:02 +0000</pubDate>
      <link>https://dev.to/andrew_davies/6-iot-trends-for-2026-translated-from-business-speak-into-developer-33k8</link>
      <guid>https://dev.to/andrew_davies/6-iot-trends-for-2026-translated-from-business-speak-into-developer-33k8</guid>
      <description>&lt;p&gt;Every January-through-April, the IoT trend reports drop — and they're all written for VPs. Market sizing, procurement gates, "strategic imperatives." Useful if you sign budgets; less useful if you write firmware.&lt;/p&gt;

&lt;p&gt;So here's the developer's cut: the trends that will actually change what you build, debug, and get paged about, with the boardroom layer stripped out.&lt;/p&gt;

&lt;p&gt;One number for context, because it drives everything below: about 21 billion IoT devices are online today, heading past 39 billion by 2030. The architecture that got us here — collect data on the device, ship it to the cloud, think there, send instructions back — is the thing quietly dying. Almost every trend on this list is a symptom of that death.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Inference is moving onto the device — and firmware just got harder&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The collect-and-send pattern made sense when cloud compute was cheap and data volumes were small. Neither is true anymore. Meanwhile, MCU-class hardware got good enough to run task-specific ML models locally: TinyML frameworks now classify vibration patterns, flag sensor anomalies, and run basic vision on devices with 256 KB of RAM, no network round-trip involved.&lt;/p&gt;

&lt;p&gt;The architectural consequence: the cloud is being demoted from decision-maker to coordinator. It aggregates fleet data, retrains models, and pushes updated weights down. The device decides.&lt;/p&gt;

&lt;p&gt;What this means for you, concretely: firmware that used to be "read sensor, transmit, sleep" now has to carry model artifacts, handle over-the-air model updates (not just firmware updates), and run inference inside a power budget. That's a genuinely harder embedded program — more state, more failure modes, more attack surface. Which leads directly to the next two trends.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Rust in firmware stops being a curiosity&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The stat that keeps showing up in government advisories: roughly 70% of high-severity vulnerabilities in C and C++ codebases are memory-safety bugs — buffer overflows, use-after-free, the classics. CISA and the NSA both cite it, and both now formally recommend memory-safe languages. Chromium's team documented the same ratio in their own code.&lt;/p&gt;

&lt;p&gt;IoT firmware is overwhelmingly C/C++. Do the math: most critical vulnerabilities in the devices around you are, in principle, preventable with a language change.&lt;/p&gt;

&lt;p&gt;Rust is where the industry landed because it's the only option that removes that bug class at compile time with zero runtime cost — no GC, no VM — which is what makes it viable on the same 256 KB microcontroller running your TinyML model. Certified toolchains (Ferrocene, qualified for automotive and medical standards) killed the "can't use it in regulated builds" objection, and automotive suppliers are already shipping Rust in ADAS firmware.&lt;/p&gt;

&lt;p&gt;Nobody sane is rewriting a million lines of working C. The actual pattern: new firmware projects in regulated domains start in Rust by default, and existing codebases swap in Rust for the security-critical modules (comm stacks, credential handling, OTA verification) over FFI. If you write embedded code and haven't touched Rust yet, 2026 is the year that gap starts showing up in job requirements.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The EU Cyber Resilience Act is about to land in your backlog&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Regulation sounds like someone else's problem until it materializes as tickets. The CRA — in force since December 2024 — is exactly that kind of regulation. The deadlines are close: conformity-assessment provisions kick in June 2026, vulnerability-reporting obligations in September 2026, full compliance by December 2027. Penalties go up to €15M or 2.5% of global turnover.&lt;/p&gt;

&lt;p&gt;Translated into engineering work, "compliance" means somebody — plausibly you — builds:&lt;/p&gt;

&lt;p&gt;a signed, verified, rollback-capable OTA pipeline that has to keep working for 10 years of security updates&lt;br&gt;
an SBOM generated from your actual build, not a spreadsheet someone maintains by hand&lt;br&gt;
a vulnerability intake and disclosure process wired into the dev workflow&lt;br&gt;
security requirements documented as design inputs, with evidence, not added at the end&lt;/p&gt;

&lt;p&gt;The full analysis of how these obligations reshape IoT architecture decisions is in the &lt;a href="https://yalantis.com/blog/iot-trends/" rel="noopener noreferrer"&gt;original trends breakdown&lt;/a&gt; this post is condensed from — the short version is that European buyers already treat CRA documentation as a qualification gate, so this work is coming to a sprint near you regardless of how anyone feels about it.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Connectivity is a portfolio now, not a picklist&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;"Which protocol should my device use" increasingly has the same answer as "which database should my app use": depends, and probably more than one. Mature 2026 deployments run several in parallel:&lt;/p&gt;

&lt;p&gt;LPWAN (LoRaWAN, NB-IoT) is still the default for anything sending small payloads infrequently — field-proven 10–15 year battery life is why smart meters and cold-chain sensors live here. NB-IoT/LTE-M crossed a billion connections.&lt;br&gt;
5G RedCap is the underrated middle tier: more capable than NB-IoT, way less power-hungry than a full 5G modem. Watch for it in asset trackers and industrial wearables the way NB-IoT showed up a few years back.&lt;br&gt;
Private 5G is for the factory floor — sub-10ms latency and extreme device density for AGVs and robotics. Overkill for everything else.&lt;br&gt;
Satellite IoT went from novelty to product: multi-orbit roaming (terrestrial NB-IoT + LEO/GEO backhaul) is commercially available, so "the container is crossing the Pacific" is no longer an excuse for a two-week data gap.&lt;/p&gt;

&lt;p&gt;The developer takeaway: design the data layer protocol-agnostic from day one. Devices that assume one transport get expensive to evolve.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Zero trust reaches all the way down to your device&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The attack chain that keeps repeating in incident reports: cheap IoT device gets popped, attacker moves laterally to the systems that actually matter. The network camera reaches the industrial controllers; the smart sensor reaches the ERP.&lt;/p&gt;

&lt;p&gt;The response — microsegmentation — is becoming a baseline procurement requirement in industrial settings (IEC 62443 shows up in RFPs constantly now). For device developers this changes an assumption: your device will live in a network that treats it as already-compromised. Design accordingly — mutual auth on every connection, no implicit trust in "internal" traffic, and the humility to accept that your device is the threat model.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Batteries become optional&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The fun one. Energy harvesting — powering sensors from ambient light, vibration, RF, or thermal differentials — has matured to where dense sensor deployments can skip batteries entirely. The engineering constraint that killed large sensor fleets was never the hardware cost; it was sending humans to swap batteries across ten thousand distributed devices. Harvesting deletes that constraint.&lt;/p&gt;

&lt;p&gt;The design catch: the harvesting method has to match the environment from day one — vibration harvesting on rotating equipment, solar on outdoor assets, RF near strong transmitters. It's a firmware problem too: your power budget stops being a fixed number and becomes a function of the environment, which makes the duty-cycle logic some of the most interesting embedded code you'll write.&lt;/p&gt;

&lt;p&gt;The thread through all of it&lt;/p&gt;

&lt;p&gt;Notice what these six have in common: the center of gravity moved to the firmware. On-device inference makes firmware smarter, Rust makes it safer, the CRA makes it a regulated artifact with a decade-long support obligation, and zero trust assumes it's hostile. The cloud-first decade trained a lot of us to treat the device as a dumb peripheral. That framing is now officially obsolete.&lt;/p&gt;

&lt;p&gt;If you're building in this space: which of these has actually hit your roadmap already? My bet is CRA prep is quietly eating more sprint capacity than the AI stuff everyone talks about — curious if the comments prove me wrong.&lt;/p&gt;

</description>
      <category>iot</category>
      <category>rust</category>
      <category>security</category>
    </item>
  </channel>
</rss>
