<?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: TechHub Nguyen</title>
    <description>The latest articles on DEV Community by TechHub Nguyen (@techhub_admin).</description>
    <link>https://dev.to/techhub_admin</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%2F4013159%2Fce80dfa7-f905-4135-99cf-338c20db7369.png</url>
      <title>DEV Community: TechHub Nguyen</title>
      <link>https://dev.to/techhub_admin</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/techhub_admin"/>
    <language>en</language>
    <item>
      <title>[Boost]</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Tue, 17 Nov 2026 09:29:12 +0000</pubDate>
      <link>https://dev.to/techhub_admin/-3igd</link>
      <guid>https://dev.to/techhub_admin/-3igd</guid>
      <description>&lt;div class="ltag__link--embedded"&gt;
  &lt;div class="crayons-story "&gt;
  &lt;a href="https://dev.to/techhub_asia/the-pwa-update-trap-why-users-get-stuck-on-old-releases-and-how-to-ship-safely-4k7a" class="crayons-story__hidden-navigation-link"&gt;The PWA Update Trap: Why Users Get Stuck on Old Releases and How to Ship Safely&lt;/a&gt;


  &lt;div class="crayons-story__body crayons-story__body-full_post"&gt;
    &lt;div class="crayons-story__top"&gt;
      &lt;div class="crayons-story__meta"&gt;
        &lt;div class="crayons-story__author-pic"&gt;
          &lt;a class="crayons-logo crayons-logo--l" href="/techhub_asia"&gt;
            &lt;img alt="TechHub Asia logo" src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F13891%2Fa6e155bb-7386-4a5c-b314-a4ebdc0b3fd5.png" class="crayons-logo__image" width="800" height="798"&gt;
          &lt;/a&gt;

          &lt;a href="/techhub_admin" class="crayons-avatar  crayons-avatar--s absolute -right-2 -bottom-2 border-solid border-2 border-base-inverted  "&gt;
            &lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4013159%2Fce80dfa7-f905-4135-99cf-338c20db7369.png" alt="techhub_admin profile" class="crayons-avatar__image" width="800" height="798"&gt;
          &lt;/a&gt;
        &lt;/div&gt;
        &lt;div&gt;
          &lt;div&gt;
            &lt;a href="/techhub_admin" class="crayons-story__secondary fw-medium m:hidden"&gt;
              TechHub Nguyen
            &lt;/a&gt;
            &lt;div class="profile-preview-card relative mb-4 s:mb-0 fw-medium hidden m:inline-block"&gt;
              
                TechHub Nguyen
                
                
              
              &lt;div id="story-author-preview-content-5055972" class="profile-preview-card__content crayons-dropdown branded-7 p-4 pt-0"&gt;
                &lt;div class="gap-4 grid"&gt;
                  &lt;div class="-mt-4"&gt;
                    &lt;a href="/techhub_admin" class="flex"&gt;
                      &lt;span class="crayons-avatar crayons-avatar--xl mr-2 shrink-0"&gt;
                        &lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4013159%2Fce80dfa7-f905-4135-99cf-338c20db7369.png" class="crayons-avatar__image" alt="" width="800" height="798"&gt;
                      &lt;/span&gt;
                      &lt;span class="crayons-link crayons-subtitle-2 mt-5"&gt;TechHub Nguyen&lt;/span&gt;
                    &lt;/a&gt;
                  &lt;/div&gt;
                  &lt;div class="print-hidden"&gt;
                    
                      Follow
                    
                  &lt;/div&gt;
                  &lt;div class="author-preview-metadata-container"&gt;&lt;/div&gt;
                &lt;/div&gt;
              &lt;/div&gt;
            &lt;/div&gt;

            &lt;span&gt;
              &lt;span class="crayons-story__tertiary fw-normal"&gt; for &lt;/span&gt;&lt;a href="/techhub_asia" class="crayons-story__secondary fw-medium"&gt;TechHub Asia&lt;/a&gt;
            &lt;/span&gt;
          &lt;/div&gt;
          &lt;a href="https://dev.to/techhub_asia/the-pwa-update-trap-why-users-get-stuck-on-old-releases-and-how-to-ship-safely-4k7a" class="crayons-story__tertiary fs-xs"&gt;&lt;time&gt;Nov 17&lt;/time&gt;&lt;span class="time-ago-indicator-initial-placeholder"&gt;&lt;/span&gt;&lt;/a&gt;
        &lt;/div&gt;
      &lt;/div&gt;

    &lt;/div&gt;

    &lt;div class="crayons-story__indention"&gt;
      &lt;h2 class="crayons-story__title crayons-story__title-full_post"&gt;
        &lt;a href="https://dev.to/techhub_asia/the-pwa-update-trap-why-users-get-stuck-on-old-releases-and-how-to-ship-safely-4k7a" id="article-link-5055972"&gt;
          The PWA Update Trap: Why Users Get Stuck on Old Releases and How to Ship Safely
        &lt;/a&gt;
      &lt;/h2&gt;
        &lt;div class="crayons-story__tags"&gt;
            &lt;a class="crayons-tag crayons-tag--filled  " href="/t/discuss"&gt;&lt;span class="crayons-tag__prefix"&gt;#&lt;/span&gt;discuss&lt;/a&gt;
            &lt;a class="crayons-tag  crayons-tag--monochrome " href="/t/webdev"&gt;&lt;span class="crayons-tag__prefix"&gt;#&lt;/span&gt;webdev&lt;/a&gt;
            &lt;a class="crayons-tag  crayons-tag--monochrome " href="/t/pwa"&gt;&lt;span class="crayons-tag__prefix"&gt;#&lt;/span&gt;pwa&lt;/a&gt;
            &lt;a class="crayons-tag  crayons-tag--monochrome " href="/t/javascript"&gt;&lt;span class="crayons-tag__prefix"&gt;#&lt;/span&gt;javascript&lt;/a&gt;
        &lt;/div&gt;
      &lt;div class="crayons-story__bottom"&gt;
        &lt;div class="crayons-story__details"&gt;
          &lt;a href="https://dev.to/techhub_asia/the-pwa-update-trap-why-users-get-stuck-on-old-releases-and-how-to-ship-safely-4k7a" class="crayons-btn crayons-btn--s crayons-btn--ghost crayons-btn--icon-left"&gt;
            &lt;div class="multiple_reactions_aggregate"&gt;
              &lt;span class="multiple_reactions_icons_container"&gt;
                  &lt;span class="crayons_icon_container"&gt;
                    &lt;img src="https://assets.dev.to/assets/exploding-head-daceb38d627e6ae9b730f36a1e390fca556a4289d5a41abb2c35068ad3e2c4b5.svg" width="24" height="24"&gt;
                  &lt;/span&gt;
                  &lt;span class="crayons_icon_container"&gt;
                    &lt;img src="https://assets.dev.to/assets/multi-unicorn-b44d6f8c23cdd00964192bedc38af3e82463978aa611b4365bd33a0f1f4f3e97.svg" width="24" height="24"&gt;
                  &lt;/span&gt;
                  &lt;span class="crayons_icon_container"&gt;
                    &lt;img src="https://assets.dev.to/assets/sparkle-heart-5f9bee3767e18deb1bb725290cb151c25234768a0e9a2bd39370c382d02920cf.svg" width="24" height="24"&gt;
                  &lt;/span&gt;
              &lt;/span&gt;
              &lt;span class="aggregate_reactions_counter"&gt;5&lt;span class="hidden s:inline"&gt;&amp;nbsp;reactions&lt;/span&gt;&lt;/span&gt;
            &lt;/div&gt;
          &lt;/a&gt;
            &lt;a href="https://dev.to/techhub_asia/the-pwa-update-trap-why-users-get-stuck-on-old-releases-and-how-to-ship-safely-4k7a#comments" class="crayons-btn crayons-btn--s crayons-btn--ghost crayons-btn--icon-left flex items-center"&gt;
              

              &lt;span class="hidden s:inline"&gt;Add&amp;nbsp;Comment&lt;/span&gt;
            &lt;/a&gt;
        &lt;/div&gt;
        &lt;div class="crayons-story__save"&gt;
          &lt;small class="crayons-story__tertiary fs-xs mr-2"&gt;
            8 min read
          &lt;/small&gt;
          
          &lt;div class="only-sidebar-menu-item trusted-visible-block print-hidden align-center"&gt;
                
                    
                
          &lt;/div&gt;

        &lt;/div&gt;
      &lt;/div&gt;
    &lt;/div&gt;
  &lt;/div&gt;
&lt;/div&gt;


&lt;/div&gt;


</description>
    </item>
    <item>
      <title>The PWA Update Trap: Why Users Get Stuck on Old Releases and How to Ship Safely</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Tue, 17 Nov 2026 09:28:51 +0000</pubDate>
      <link>https://dev.to/techhub_asia/the-pwa-update-trap-why-users-get-stuck-on-old-releases-and-how-to-ship-safely-4k7a</link>
      <guid>https://dev.to/techhub_asia/the-pwa-update-trap-why-users-get-stuck-on-old-releases-and-how-to-ship-safely-4k7a</guid>
      <description>&lt;p&gt;You ship a release. A user opens your installed PWA and sees last week's UI. You reload, it still shows last week's UI, and clearing the cache "fixes" it, which is the worst possible support answer.&lt;/p&gt;

&lt;p&gt;The cause is rarely one bug. It's an interaction between three things: how the HTML document is cached, how the service worker is versioned, and which asset files exist after a deploy. This post reproduces three failures with a two-release lab, then shows the deploy pattern that avoids them.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;TL;DR&lt;/em&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A service worker update is detected by a byte difference, then installs and waits. A page reload does not release it.&lt;/li&gt;
&lt;li&gt;Cache First for the HTML document, a worker URL that changes per release, and unconditional skipWaiting() each create a different failure.&lt;/li&gt;
&lt;li&gt;The safer pattern: Network First navigation, a stable worker URL, a user-consented skipWaiting(), and keeping the previous release's cache for open tabs.&lt;/li&gt;
&lt;li&gt;Everything below ran in headless Chromium 153. I did not test Safari or Firefox, so repeat the checks there.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The service worker lifecycle in 60 seconds
&lt;/h2&gt;

&lt;p&gt;A service worker is a script the browser runs separately from your page, so it can intercept requests. Updates follow a fixed sequence:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Detection: your worker counts as updated if it's byte-different from the one the browser already has. An update check is triggered by a navigation to an in-scope page, or by functional events such as push and sync (unless there was a check in the last 24 hours).&lt;/li&gt;
&lt;li&gt;Install: the new worker installs alongside the old one. If it returns a non-OK status such as a 404, fails to parse, or rejects during install, the new worker is thrown away and the current one stays active.&lt;/li&gt;
&lt;li&gt;Waiting: once installed, the new worker waits until the existing worker controls zero clients. Clients overlap during a refresh, so a reload does not release it.&lt;/li&gt;
&lt;li&gt;Activate: the worker activates. self.skipWaiting() skips the waiting step, and clients.claim() takes control of pages that loaded without the worker.&lt;/li&gt;
&lt;li&gt;Script caching: most browsers, including Chrome 68 and later, ignore HTTP caching headers when checking the registered worker script. Imported scripts still respect them unless you set updateViaCache.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Why the "one version at a time" rule exists: two tabs running different versions of a site can disagree about shared storage, which can cause errors or, worse, data loss.&lt;/p&gt;

&lt;h2&gt;
  
  
  The lab: two releases and a real browser
&lt;/h2&gt;

&lt;p&gt;To avoid hand-waving, I built a small lab. A build script generates two releases of a tiny app. A static server serves one of them and lets a test "deploy" the next. A Puppeteer test then drives Chromium through the failure and asserts what the user sees.&lt;/p&gt;

&lt;p&gt;Two details matter:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;em&gt;Every response is Cache-Control: no-cache.&lt;/em&gt; Any staleness you see comes from the service worker, not the HTTP cache.&lt;/li&gt;
&lt;li&gt;
&lt;em&gt;The app has a lazy-loaded chunk&lt;/em&gt; (feature.v1.js) behind a button, like a route or feature a bundler would split out. Version skew shows up there.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The repo is here: [REPO URL: publish sw-update-lab and insert the link]. Run it with npm install &amp;amp;&amp;amp; npm test.&lt;/p&gt;

&lt;h2&gt;
  
  
  Repro 1: Cache First HTML
&lt;/h2&gt;

&lt;p&gt;The worker precaches the document and serves everything cache-first, including navigations:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;addEventListener&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'fetch'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;respondWith&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;caches&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;match&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;request&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;then&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;hit&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;hit&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nb"&gt;fetch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;request&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="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;Steps&lt;/em&gt;: load release 1 and reload once so the page is controlled, deploy release 2, then reload.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;What I observed&lt;/em&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;After the deploy, three reloads all still showed release 1.&lt;/li&gt;
&lt;li&gt;The browser did find the new worker. It installed and sat in the waiting state behind the old one.&lt;/li&gt;
&lt;li&gt;Another reload did not release it.&lt;/li&gt;
&lt;li&gt;After closing every tab and opening a fresh one, release 2 appeared.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The new HTML was never fetched, because the old worker answered the navigation from its cache. The user is stuck until the old worker has zero clients, which can take a long time if people keep the app open or resume it from the background. I haven't measured how often real users fully close a PWA, so treat that as a risk, not a rate.&lt;/p&gt;

&lt;h2&gt;
  
  
  Repro 2: a worker URL that changes every release
&lt;/h2&gt;

&lt;p&gt;Some build setups put a hash in the worker filename and register that URL:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight html"&gt;&lt;code&gt;&lt;span class="nt"&gt;&amp;lt;script&amp;gt;&lt;/span&gt;
  &lt;span class="n"&gt;navigator&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;serviceWorker&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;register&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'/sw.'&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="no"&gt;RELEASE&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="s1"&gt;'.js'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// /sw.v1.js, then /sw.v2.js&lt;/span&gt;
&lt;span class="nt"&gt;&amp;lt;/script&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Release 2 ships /sw.v2.js and no longer serves /sw.v1.js. With the cached HTML still calling the old registration, nothing tells the browser about the new URL.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;What I observed:&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;TypeError: Failed to update a ServiceWorker for scope ('http://localhost:…/')
with script ('http://localhost:…/sw.v1.js'):
A bad HTTP response code (404) was received when fetching the script.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;ul&gt;
&lt;li&gt;The browser keeps checking the URL it registered. That URL 404s, so the update is discarded and the old worker stays active.&lt;/li&gt;
&lt;li&gt;There was no waiting worker.&lt;/li&gt;
&lt;li&gt;Closing every tab did not help. A fresh tab still showed release 1, because the active worker served it from cache.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This one doesn't heal on its own. The fix is to keep a worker at the old URL.&lt;/p&gt;

&lt;h3&gt;
  
  
  Fix: a rescue worker at the old URL
&lt;/h3&gt;

&lt;p&gt;From release 2 on, serve something at /sw.v1.js that cleans up and sends clients on their way:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="c1"&gt;// served at the OLD worker URL from release 2 onwards&lt;/span&gt;
&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;addEventListener&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'install'&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="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;skipWaiting&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;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;addEventListener&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'activate'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;waitUntil&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;async&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt; &lt;span class="k"&gt;of&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;caches&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;keys&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="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;caches&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="k"&gt;delete&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;registration&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;unregister&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="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;windows&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;clients&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;matchAll&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'window'&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;windows&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;forEach&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;navigate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;url&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="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="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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;What I observed:&lt;/em&gt; the stuck client's next update check fetched the rescue worker, which activated, cleared caches, unregistered itself and reloaded the tab. The page came back as release 2 and registered /sw.v2.js.&lt;/p&gt;

&lt;p&gt;Then stop changing the worker URL. Register /sw.js every time, and let the byte difference trigger updates.&lt;/p&gt;

&lt;h2&gt;
  
  
  Repro 3: skipWaiting() under an open tab
&lt;/h2&gt;

&lt;p&gt;skipWaiting() looks like the answer to Repro 1, so many guides add it, together with cache cleanup and clients.claim():&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;addEventListener&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'install'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;skipWaiting&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;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;waitUntil&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;caches&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;CACHE&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;then&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;addAll&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;ASSETS&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="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;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;addEventListener&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'activate'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;waitUntil&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;caches&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;keys&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="nf"&gt;then&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;keys&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;Promise&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;all&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;keys&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;filter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;k&lt;/span&gt; &lt;span class="o"&gt;!==&lt;/span&gt; &lt;span class="no"&gt;CACHE&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;map&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;caches&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="k"&gt;delete&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;k&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="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;then&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="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;clients&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;claim&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="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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;Steps:&lt;/em&gt; keep a release 1 tab open, deploy release 2, let the update check run, then click "Load feature" in the old tab.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;What I observed:&lt;/em&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;FAILED: Failed to fetch dynamically imported module: http://localhost:…/feature.v1.js
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The old page is still running release 1 code, but the new worker has deleted release 1's cache, and the server no longer has feature.v1.js. Any lazy route, image or API shape that changed between releases can break the same way. The same version mismatch can also hit shared storage.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;A note on timing.&lt;/em&gt; My first version of this test passed by accident. It clicked while the new worker was still activating, and the release 1 cache still existed. I fixed the test to wait for activation. Version skew bugs are timing-dependent, so "it worked when I tried it" proves little.&lt;/p&gt;

&lt;h2&gt;
  
  
  Safe patterns for a service worker update strategy
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fbxogkfuv31nvqn6ikwsc.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fbxogkfuv31nvqn6ikwsc.png" alt="Failure, Causes and Fix Table"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Network First for navigations, Cache First for versioned assets
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;request&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;mode&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="s1"&gt;'navigate'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;respondWith&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;async&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;try&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nb"&gt;fetch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;request&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;                       &lt;span class="c1"&gt;// always try the network for the HTML&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;catch&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;cache&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;caches&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;CACHE&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;            &lt;span class="c1"&gt;// this release's cache, explicitly&lt;/span&gt;
      &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;cache&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;match&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'/index.html'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nc"&gt;Response&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;error&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="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="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="c1"&gt;// Hashed asset URLs never change content, so Cache First is safe here.&lt;/span&gt;
&lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;respondWith&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;caches&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;match&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;request&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;then&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;hit&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;hit&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nb"&gt;fetch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;request&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Open the current cache by name for the fallback. caches.match() searches every cache, in creation order, so an older cache can answer first. In production, consider a network timeout (Workbox's NetworkFirst has networkTimeoutSeconds), because plain Network First waits for a failing connection.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Prompt, then skipWaiting(), then reload
&lt;/h3&gt;

&lt;p&gt;Let the page detect the waiting worker and ask. Chrome's Workbox docs describe this as waiting event, user accepts, messageSkipWaiting(), reload on controlling. In plain code:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="c1"&gt;// page&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;reg&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;navigator&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;serviceWorker&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;register&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'/sw.js'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;updateViaCache&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'none'&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="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;prompt&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;reg&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;waiting&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;navigator&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;serviceWorker&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;controller&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;showUpdateButton&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="p"&gt;;&lt;/span&gt;
&lt;span class="nf"&gt;prompt&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;reg&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;addEventListener&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'updatefound'&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="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;reg&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;installing&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;addEventListener&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'statechange'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;prompt&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;updateButton&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;onclick&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;accepted&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="n"&gt;reg&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;waiting&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;postMessage&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'SKIP_WAITING'&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="p"&gt;;&lt;/span&gt;
&lt;span class="n"&gt;navigator&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;serviceWorker&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;addEventListener&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'controllerchange'&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="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;accepted&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;location&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;reload&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="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="c1"&gt;// service worker&lt;/span&gt;
&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;addEventListener&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'message'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="o"&gt;?&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="s1"&gt;'SKIP_WAITING'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;skipWaiting&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="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If you use Workbox's generateSW with skipWaiting left at its default of false, the message listener is included for you. The Workbox docs also say a prompt makes the most sense when you precache heavily or serve precached HTML.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;What I observed:&lt;/em&gt; after a deploy, the page showed the update prompt and stayed on release 1 with a working lazy chunk. After accepting, the page reloaded into release 2.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Keep the previous release's cache
&lt;/h3&gt;

&lt;p&gt;Delete only caches older than the previous release:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt; &lt;span class="k"&gt;of&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;caches&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;keys&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="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;Number&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;replace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'app-v'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&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="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;Number&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;isFinite&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="no"&gt;N&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;caches&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="k"&gt;delete&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;key&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;em&gt;What I observed:&lt;/em&gt; with a second tab still on release 1, accepting the update in the first tab activated the new worker. The second tab's "Load feature" click still returned feature v1 ok, served from the retained cache.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Practices I did not test in the lab
&lt;/h3&gt;

&lt;p&gt;These are standard practice, but the lab doesn't cover them:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Keep old hashed assets on the server for a release or two, so open tabs can still fetch them.&lt;/li&gt;
&lt;li&gt;Call registration.update() when the app becomes visible. Update checks are triggered by navigations and functional events, and a long-lived single-page app may not navigate for days.&lt;/li&gt;
&lt;li&gt;Catch lazy-chunk load errors in the app and offer a reload, rather than leaving a blank screen.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Testing updates locally and in CI
&lt;/h2&gt;

&lt;p&gt;The test pattern is the same for every scenario:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;installAndControl&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;page&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;          &lt;span class="c1"&gt;// register, wait for 'ready', reload so the page is controlled&lt;/span&gt;
&lt;span class="n"&gt;assert&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;equal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;version&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;page&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;'v1'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="n"&gt;lab&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;deploy&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;                          &lt;span class="c1"&gt;// release 2 is now live&lt;/span&gt;
&lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;checkForUpdate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;page&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;             &lt;span class="c1"&gt;// registration.update()&lt;/span&gt;

&lt;span class="n"&gt;assert&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;equal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;version&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;page&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;'v1'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;   &lt;span class="c1"&gt;// still release 1 until the update is applied&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Four lessons from writing these tests:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Wait for states, not time. Wait for reg.waiting, or for reg.active.state === 'activated', before asserting.&lt;/li&gt;
&lt;li&gt;A reload does not release a waiting worker. Closing all clients does, which is why Repro 1 needs a second page.&lt;/li&gt;
&lt;li&gt;Use a fresh browser per test. Each run needs its own service worker storage.&lt;/li&gt;
&lt;li&gt;Keep DevTools' "Update on reload" off when you want to see what users see, because it forces an update check on every load.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In CI, install a Chrome binary and point the tests at it with CHROME_PATH (and NO_SANDBOX=1 in containers).&lt;/p&gt;

&lt;h2&gt;
  
  
  Checklist for reviewers
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;The worker is registered at one stable URL (/sw.js), not a per-release filename.&lt;/li&gt;
&lt;li&gt;HTML navigations are Network First or otherwise revalidated, never plain Cache First.&lt;/li&gt;
&lt;li&gt;Cache First is used only for assets with content-hashed URLs.&lt;/li&gt;
&lt;li&gt;skipWaiting() runs on user consent, not unconditionally in install.&lt;/li&gt;
&lt;li&gt;The page reloads only after controllerchange that follows an accepted update.&lt;/li&gt;
&lt;li&gt;Cache cleanup keeps the previous release for open tabs.&lt;/li&gt;
&lt;li&gt;The offline navigation fallback reads the active release's cache, not the first match.&lt;/li&gt;
&lt;li&gt;Old hashed assets stay on the server for at least one release.&lt;/li&gt;
&lt;li&gt;Long-lived sessions call registration.update() on a sensible trigger.&lt;/li&gt;
&lt;li&gt;A two-release test exists, and runs in CI, with a waiting-worker assertion.&lt;/li&gt;
&lt;li&gt;A rescue worker exists if you ever shipped a per-release worker URL.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;Update bugs come from the combination: cached HTML, worker versioning and which assets still exist after a deploy. Test with two releases, wait for lifecycle states, and let the user choose when to switch.&lt;/p&gt;

&lt;p&gt;If you're hiring for PWA work, update behavior is one of the first things worth probing. See what to ask a candidate about updates in &lt;a href="https://techhub.asia/hire-progressive-web-app-developers/" rel="noopener noreferrer"&gt;our complete guide to hiring PWA developers&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>pwa</category>
      <category>javascript</category>
      <category>discuss</category>
    </item>
    <item>
      <title>What Multi-User Adds to a VR Project: Scope, Skills and Risk</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Tue, 10 Nov 2026 02:23:03 +0000</pubDate>
      <link>https://dev.to/techhub_asia/what-multi-user-adds-to-a-vr-project-scope-skills-and-risk-309g</link>
      <guid>https://dev.to/techhub_asia/what-multi-user-adds-to-a-vr-project-scope-skills-and-risk-309g</guid>
      <description>&lt;p&gt;What changes when a VR project becomes multi-user: authority, latency, identity, voice, permissions and backend, with a scoping checklist.&lt;/p&gt;

&lt;p&gt;Making a VR project multi-user adds six areas of work that a single-user app does not have: state synchronization and authority, latency handling, identity and authentication, voice, permissions and session management, and backend operations. Each one adds scope, needs different skills and carries its own risk. The decision with the widest consequences is the authority model, meaning who is allowed to decide the shared state, and it is best settled before estimating anything. This guide walks through each area, the test strategy shared VR needs, the skills to hire for, and a scoping checklist.&lt;/p&gt;

&lt;p&gt;It is written for technical leads and product managers planning a shared VR experience. It is not a netcode tutorial. Tool names and statuses change quickly, so check each vendor's current documentation before committing.&lt;/p&gt;

&lt;h2&gt;
  
  
  Single-user versus shared: what actually changes
&lt;/h2&gt;

&lt;p&gt;In a single-user app there is one simulation and one source of truth. In a shared app, several running instances, each on its own headset, must agree on what is true. Every user's head and hand positions, every object they touch and every change to the environment becomes data that must be agreed, transmitted and reconciled.&lt;/p&gt;

&lt;p&gt;Engines handle part of this, but the design decisions stay yours. Unreal Engine uses a client-server architecture in which the server holds the authoritative game state and clients simulate an approximation of it. A useful side note from the same documentation: gameplay written for multiplayer still works in single-player, which is one reason many teams design for networking from the start instead of retrofitting it. The second half is general engineering experience, not a documented rule.&lt;/p&gt;

&lt;h2&gt;
  
  
  The six areas of added scope
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. State synchronization and authority
&lt;/h3&gt;

&lt;p&gt;The first decision is who is in charge of the shared state. The main options:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Server-authoritative (client-server). Unity's Netcode for GameObjects assumes a client-server topology by default, where the server owns networked objects and has ultimate authority. Unreal's documentation says dedicated servers suit games with many players, or those needing a trusted server for security, fairness or reliability.&lt;/li&gt;
&lt;li&gt;Distributed authority. Netcode for GameObjects also supports a distributed authority topology, where authority is spread across clients. Unity describes the main differences between the two models as cost, security and latency. It also advises evaluating your tolerance for cheating before choosing distributed authority, and notes that one client acts as the session owner, managing global state.&lt;/li&gt;
&lt;li&gt;Vendor-provided topologies. Photon Fusion for Unity supports shared, client-host and dedicated-server topologies.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The right choice depends on trust, cost and session size. A collaborative design review among colleagues has a different cheating tolerance from a public social space. Pick the model deliberately and record who made the decision, because changing it later touches most of the networked code.&lt;/p&gt;

&lt;p&gt;VR adds its own load to synchronization. Each user's head and both hands are tracked continuously, so avatars require a steady stream of pose data. Objects that users hold need a clear ownership rule: who controls a held object, and what happens when it is passed to another user or two users grab it at once. These are design points to settle early. They are not features to bolt on.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Latency and prediction
&lt;/h3&gt;

&lt;p&gt;Network latency cannot be removed, only managed. With a client-server topology, latency depends heavily on the location and architecture of the server, so where servers run matters as much as the code.&lt;/p&gt;

&lt;p&gt;A principle widely used in practice, which this article treats as analysis: a user's own head and hand movement should be rendered locally without waiting for the network, while remote users' movement is smoothed over the data that arrives. Waiting on the network for your own view would be uncomfortable in a headset. Decide early which actions need immediate local response, which can tolerate delay, and how you will show remote users when updates arrive late.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Identity and authentication
&lt;/h3&gt;

&lt;p&gt;Shared VR needs to know who is present. On Quest, Meta provides a verification flow for this. The client generates a nonce, your trusted server validates it through a server-to-server call, and the result confirms the Meta account is valid for the user presenting it. Meta states that this does not replace the entitlement check, and that Platform SDK features require a Data Use Checkup before they work beyond test users. That last point is schedule risk: plan for the review time.&lt;/p&gt;

&lt;p&gt;Enterprise projects often also need to connect to the organization's own sign-on and user directory. That is an integration task with its own skills and security review. It is not an engine feature.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Voice
&lt;/h3&gt;

&lt;p&gt;Voice is often what makes shared VR useful, and it is a separate subsystem from state sync. Decide whether you need spatial or proximity voice, how users mute and are moderated, and whether anything is recorded or stored. Recording and retention raise privacy and consent questions that belong with legal advice, not with the engine. For tooling, Photon lists a dedicated voice product that covers team, proximity and spatial voice, and other vendors and platform services exist. Confirm each option's current status and its support for your engine and headset before choosing.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Permissions and session management
&lt;/h3&gt;

&lt;p&gt;A shared space needs rules. This area is analysis. Define:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Roles. Who can present, edit, annotate, or only view?&lt;/li&gt;
&lt;li&gt;Access. Who can create, join or be invited to a session?&lt;/li&gt;
&lt;li&gt;Moderation. Who can mute or remove someone?&lt;/li&gt;
&lt;li&gt;Lifecycle. What happens when someone joins late, drops and reconnects, or the host leaves?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Late join is an easy one to underestimate. A newcomer needs the current state of the world, not only future updates, and that state has to be stored and sent.&lt;/p&gt;

&lt;h3&gt;
  
  
  6. Backend and operations
&lt;/h3&gt;

&lt;p&gt;Shared VR usually needs infrastructure beyond the headset app: servers or relay services, session and matchmaking services, persistence of shared data, analytics, monitoring and a way to deploy updates. Each brings running costs and an on-call burden. The pillar notes that backend, accounts, analytics and multiplayer expand scope beyond the headset application. This is where that scope shows up.&lt;/p&gt;

&lt;h2&gt;
  
  
  Tooling categories and current status
&lt;/h2&gt;

&lt;p&gt;These are categories to evaluate, not recommendations. Tool statuses change, so verify each before relying on it.&lt;/p&gt;

&lt;h3&gt;
  
  
  State synchronization
&lt;/h3&gt;

&lt;p&gt;When building networked spatial experiences, state synchronization is the foundational layer. Examples named in this article include engine-native replication in Unreal, Netcode for GameObjects in Unity, and Photon Fusion.&lt;br&gt;
&lt;strong&gt;What to confirm&lt;/strong&gt;: Engineering teams must confirm supported network topologies, exact engine and version compatibility, and the ongoing maintenance status of the selected solution.&lt;/p&gt;
&lt;h3&gt;
  
  
  Session and hosting
&lt;/h3&gt;

&lt;p&gt;Managing how users connect requires selecting the appropriate infrastructure, such as vendor-hosted services, dedicated servers, or host-based sessions.&lt;br&gt;
&lt;strong&gt;What to confirm&lt;/strong&gt;: Leadership must evaluate the underlying cost model, available hosting regions, and absolute scaling limits before committing to an architecture.&lt;/p&gt;
&lt;h3&gt;
  
  
  Identity
&lt;/h3&gt;

&lt;p&gt;User authentication in spatial computing often bridges consumer platforms and enterprise systems, utilizing standard platform account verification or organization sign-on.&lt;br&gt;
&lt;strong&gt;What to confirm&lt;/strong&gt;: Security teams must verify all platform review requirements and mandate strict server-side validation to prevent unauthorized access.&lt;/p&gt;
&lt;h3&gt;
  
  
  Voice
&lt;/h3&gt;

&lt;p&gt;Real-time communication relies heavily on specialized vendor voice products integrated directly into the spatial environment.&lt;br&gt;
&lt;strong&gt;What to confirm&lt;/strong&gt;: Technical leads must evaluate spatial audio support, available moderation tools, and strict data retention policies.&lt;/p&gt;
&lt;h3&gt;
  
  
  Backend and analytics
&lt;/h3&gt;

&lt;p&gt;Tracking user behavior and application state requires robust backend infrastructure, typically relying on custom APIs or managed services.&lt;br&gt;
&lt;strong&gt;What to confirm&lt;/strong&gt;: Organizations must prioritize verifying the exact data storage location, passing a comprehensive security review, and projecting the long-term operating cost.&lt;/p&gt;

&lt;p&gt;On status: Photon's documentation, as of July 2026, lists Fusion 2 as current for Unity, with Fusion 3 SDKs for Unreal and Godot, and describes PUN 2 as in maintenance mode, with new projects pointed to Fusion or Quantum. If your team inherits a PUN-based codebase, treat the migration as a scoping item.&lt;/p&gt;
&lt;h2&gt;
  
  
  Test strategy for shared VR
&lt;/h2&gt;

&lt;p&gt;You cannot validate a shared experience with one headset and one editor session. The extra testing effort is real, so budget for it. These are recommended practices, not documented requirements:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Multi-device runs. Test with several real headsets in the same session, not only editor instances.&lt;/li&gt;
&lt;li&gt;Bad networks. Test under added latency, jitter and packet loss, and check that the experience degrades gracefully.&lt;/li&gt;
&lt;li&gt;Join, leave and reconnect. Test late joiners, abrupt disconnects and reconnecting users.&lt;/li&gt;
&lt;li&gt;Role and permission checks. Confirm that restricted roles really are restricted.&lt;/li&gt;
&lt;li&gt;Performance with N users. Each additional avatar adds work. Re-run your profiling on the target headset with the maximum expected number of users.&lt;/li&gt;
&lt;li&gt;Soak tests. Run long sessions to expose memory growth and state drift.&lt;/li&gt;
&lt;li&gt;Load tests on the backend, independent of headsets.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Write the acceptance criteria before building. For example: the maximum users per session you will support, the network conditions the experience must tolerate, and the behavior expected on reconnect.&lt;/p&gt;
&lt;h2&gt;
  
  
  Skills to hire for
&lt;/h2&gt;

&lt;p&gt;Shared VR spreads work across more disciplines than single-user. A common split, which is an editorial suggestion:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;VR engineer with networking experience: synchronization, authority, local prediction, interaction ownership.&lt;/li&gt;
&lt;li&gt;Backend engineer: session services, identity integration, persistence, APIs.&lt;/li&gt;
&lt;li&gt;DevOps or site reliability engineer: deployment, monitoring, scaling, incident response.&lt;/li&gt;
&lt;li&gt;QA with a multi-device setup: coordinated tests across headsets and network conditions.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;One person rarely covers all of this. For a broader view of &lt;a href="https://techhub.asia/hire-vr-developers/" rel="noopener noreferrer"&gt;VR developer skills for multiplayer projects&lt;/a&gt;, including how they fit into the wider role definition, see TechHub Asia's overview.&lt;/p&gt;
&lt;h2&gt;
  
  
  Scoping checklist
&lt;/h2&gt;

&lt;p&gt;Copy this into your project documents. Each row names the decisions to settle and the question to put to a vendor or candidate.&lt;/p&gt;
&lt;h3&gt;
  
  
  Authority and topology
&lt;/h3&gt;

&lt;p&gt;When engineering networked environments, teams must settle on the core architecture by choosing between client-server, distributed authority, or host-based models, while explicitly defining who owns held objects. Leadership must ask the foundational question, "Which model, and why, for our trust and cost needs?" Failing to address this early carries the severe risk of forcing a late redesign of networked code.&lt;/p&gt;
&lt;h3&gt;
  
  
  Latency and prediction
&lt;/h3&gt;

&lt;p&gt;To maintain user immersion, developers must finalize decisions regarding locally rendered actions, remote smoothing, and server regions. Leadership should challenge the technical team by asking, "How do you keep a user's own movement local?" Skipping this evaluation results in physical discomfort and a completely unusable experience for the end user.&lt;/p&gt;
&lt;h3&gt;
  
  
  Identity
&lt;/h3&gt;

&lt;p&gt;Securing access requires settling parameters around platform accounts, organization sign-on, and strict server-side validation. Security stakeholders must ask, "Who validates identity, and where?" Ignoring these constraints leads directly to security gaps and platform review delays.&lt;/p&gt;
&lt;h3&gt;
  
  
  Voice
&lt;/h3&gt;

&lt;p&gt;Real-time communication demands immediate decisions on whether audio should be spatial or standard, alongside establishing clear moderation and recording policies. Technical leads must ask, "What is stored, and for how long?" Proceeding without these answers creates massive privacy and legal exposure.&lt;/p&gt;
&lt;h3&gt;
  
  
  Permissions and sessions
&lt;/h3&gt;

&lt;p&gt;Managing active environments involves configuring user roles, invites, late joining mechanics, and session reconnection logic. Engineering teams must proactively ask, "What happens when the host leaves?" Overlooking this architectural detail will consistently result in broken sessions.&lt;/p&gt;
&lt;h3&gt;
  
  
  Backend and operations
&lt;/h3&gt;

&lt;p&gt;Long-term project viability relies on finalizing plans for hosting, data persistence, active monitoring, and overarching operational costs. Leadership must secure the future of the product by asking, "Who runs it after launch?" Neglecting this handoff directly results in unplanned running costs.&lt;/p&gt;
&lt;h3&gt;
  
  
  Testing
&lt;/h3&gt;

&lt;p&gt;Validating multiplayer environments requires settling the exact physical devices to be used, simulating diverse network conditions, and proving N-user performance limits. Quality assurance teams must ask, "How will we test with many headsets?" Bypassing this crucial scale testing guarantees that critical failures will be found only in production.&lt;/p&gt;

&lt;p&gt;A short, tool-neutral record of the key limits also helps. This template contains placeholders only:’&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;multi_user_scope&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;max_users_per_session&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;?&lt;/span&gt;          &lt;span class="c1"&gt;# drives topology, cost and performance budget
&lt;/span&gt;  &lt;span class="na"&gt;authority_model&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;?&lt;/span&gt;                &lt;span class="c1"&gt;# client-server | distributed | host-based (name an owner)
&lt;/span&gt;  &lt;span class="na"&gt;target_headsets&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;?&lt;/span&gt;
  &lt;span class="na"&gt;tolerated_network&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;latency_ms&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;?&lt;/span&gt;
    &lt;span class="na"&gt;packet_loss_pct&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;?&lt;/span&gt;
  &lt;span class="na"&gt;voice&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;?&lt;/span&gt;                          &lt;span class="c1"&gt;# none | spatial | team; recording yes/no
&lt;/span&gt;  &lt;span class="na"&gt;identity&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;?&lt;/span&gt;                       &lt;span class="c1"&gt;# platform account | organization sign-on
&lt;/span&gt;  &lt;span class="na"&gt;roles&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;?&lt;/span&gt;
  &lt;span class="na"&gt;late_join_and_reconnect&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;?&lt;/span&gt;        &lt;span class="c1"&gt;# required behavior
&lt;/span&gt;  &lt;span class="na"&gt;backend_owner_after_launch&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;?&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  The takeaway
&lt;/h2&gt;

&lt;p&gt;Treat multi-user as a different project, not a feature. Settle the authority model first, write acceptance criteria for latency, reconnect and user count, budget for backend and multi-device testing, and staff for more than one discipline. If those answers are unclear, the estimate will be too.&lt;br&gt;
&lt;a href="https://techhub.asia/hire-vr-developers/" rel="noopener noreferrer"&gt;Check our full hiring guide&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://techhub.asia/contact-us/" rel="noopener noreferrer"&gt;Contact TechHub Asia&lt;/a&gt;&lt;/p&gt;

</description>
      <category>vr</category>
      <category>gamedev</category>
      <category>multiplayer</category>
      <category>discuss</category>
    </item>
    <item>
      <title>Profiling VR Performance on Target Hardware: Measure Before You Optimize</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Mon, 02 Nov 2026 07:06:35 +0000</pubDate>
      <link>https://dev.to/techhub_asia/profiling-vr-performance-on-target-hardware-measure-before-you-optimize-14fg</link>
      <guid>https://dev.to/techhub_asia/profiling-vr-performance-on-target-hardware-measure-before-you-optimize-14fg</guid>
      <description>&lt;p&gt;To find out why a VR build drops frames, measure it on the target headset first, work out whether you are missing the frame budget at all, then classify the bottleneck as CPU, GPU, memory or thermal before changing anything. Change one thing at a time, re-measure, and finish by turning the result into a regression check. This article walks through that workflow. Its examples come from Meta Quest documentation, because that is the platform with the most public tooling guidance. The method applies to any standalone headset, but the numbers are device-specific, so take them from your own platform's current docs.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why VR is less forgiving, and what the target is
&lt;/h2&gt;

&lt;p&gt;A missed frame in a flat-screen app is a visual blip. In VR it can break immersion and cause discomfort, so platforms set hard floors.&lt;/p&gt;

&lt;p&gt;On Quest, Meta's store requirement states that apps must sustain a rendering rate of at least 60 fps and, for interactive apps, use an allowed refresh rate of 72, 80, 90, 96, 100 or 120 Hz, with some rates unavailable on some devices. The same requirement allows half-rate rendering during portions that use Application SpaceWarp, and Meta notes it is one of the most commonly failed requirements. That page has a changelog, with entries as recent as October 2025, so check the current version for your device before fixing a target.&lt;/p&gt;

&lt;p&gt;The refresh rate sets your per-frame time budget. At 72 Hz the display refreshes every 13.9 ms, which becomes 11.1 ms at 90 Hz and 8.3 ms at 120 Hz. Two practical consequences follow:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Meta advises requesting a higher refresh rate only if the app can sustain it, because a smooth 72 Hz is better than a 90 Hz experience with frequent dropped frames.&lt;/li&gt;
&lt;li&gt;If an app requests more than 72 Hz and the device comes under thermal pressure, the OS may throttle the refresh rate back to 72 Hz, and under worse conditions halve the effective frame rate. A scene that passes a thirty-second test can therefore fail a twenty-minute session.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Standalone versus tethered
&lt;/h2&gt;

&lt;p&gt;Quest headsets are standalone devices that need no PC, so everything runs inside the headset's own thermal and memory limits. Meta documents per-app memory kill limits of 4.4 GiB on Quest 2 and Quest Pro and 5.75 GiB on Quest 3, Quest 3S and Meta VR Glasses. A PC-tethered setup moves the constraints to the PC's hardware and the link to the headset. If you target it, profile on the minimum PC specification you intend to support, not on your development machine. In both cases, editor or desktop numbers do not transfer to the device, which is why the first rule is to measure on the real hardware.&lt;/p&gt;

&lt;h2&gt;
  
  
  Set up the measurement before touching the code
&lt;/h2&gt;

&lt;p&gt;A good measurement protocol matters more than any single tool. Use these habits, which are editorial recommendations:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Profile a development build on the device, not the editor.&lt;/li&gt;
&lt;li&gt;Use a repeatable scenario. Walk the same path, in the same scene, for the same duration, so two captures are comparable.&lt;/li&gt;
&lt;li&gt;Run long enough to include thermal behavior. Capture both a cold start and a sustained session.&lt;/li&gt;
&lt;li&gt;Report percentiles and worst cases, not only averages. Averages hide the spikes that users feel.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Meta's tooling covers most needs:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Meta Quest Developer Hub bundles a Performance Analyzer and Perfetto access.&lt;/li&gt;
&lt;li&gt;OVR Metrics Tool provides a real-time on-screen graph overlay of app and headset metrics, plus exportable reports.&lt;/li&gt;
&lt;li&gt;RenderDoc Meta Fork exposes low-level GPU data, including render stages and individual draw calls.&lt;/li&gt;
&lt;li&gt;Unreal Insights helps find bottlenecks, spikes and threading patterns.&lt;/li&gt;
&lt;li&gt;Perfetto is engine-agnostic and shows system processes and extra metrics on the same timeline as the app profile. Unity and Unreal developers must enter their package name in the ATrace Apps field to get detailed Perfetto information.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The triage workflow
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Step 1: Are you actually missing the budget?
&lt;/h3&gt;

&lt;p&gt;Convert your refresh rate to a budget, then capture frame times and look at the pattern. Constant overruns usually mean a steady-state cost, such as too much geometry or an expensive shader. Isolated spikes point to hitches, for example garbage collection, streaming or loading. Meta's Unity tutorial lists GPU bottlenecks, CPU spikes and garbage-collection pressure as the kinds of problems a trace can reveal.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 2: CPU-bound or GPU-bound?
&lt;/h3&gt;

&lt;p&gt;Answer this before anything else, because the fixes are different. Meta's workflow suggests rendering nothing at all: if performance barely changes, the app is likely CPU-bound, and if it improves significantly, it is likely GPU-bound. There are also on-device indicators. Meta's Showdown write-up explains that if an app is at a high CPU level but a low GPU level, it must be CPU-bound because GPU headroom remains, and that GPU utilization maxed at 100% indicates a GPU-bound app.&lt;/p&gt;

&lt;p&gt;One caveat from the same guide: the render-nothing test counts some CPU-side work, such as frustum culling, as vertex-bound work, so treat the result as a strong hint rather than a verdict.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 3a: If CPU-bound, find which thread
&lt;/h3&gt;

&lt;p&gt;Meta's guidance asks whether the main thread or the render thread is taking too long, and for Unreal it points to the Game and Draw thread values on the device. Typical causes are scripts and physics on the main thread, animation cost, and the cost of submitting draw calls on the render thread. Treat these as hypotheses to confirm in the trace.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 3b: If GPU-bound, vertex or fragment?
&lt;/h3&gt;

&lt;p&gt;Meta's guidance splits GPU-bound apps into vertex-heavy and fragment-heavy, and says simplifying complex geometry and reducing draw calls often fixes the vertex-bound case, with an LOD system or draw-call batching depending on the app. Fragment-bound problems typically come from shading cost, overdraw and render resolution. That last list is general graphics practice, not a Meta quotation.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 4: Check memory and thermal state
&lt;/h3&gt;

&lt;p&gt;Even with good frame times, a build that creeps toward the memory limit or heats the device over a long session will fail later. Check peak memory against the device limit and repeat the capture after a sustained run to see whether the refresh rate or frame times degrade.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 5: Rule out content and network
&lt;/h3&gt;

&lt;p&gt;Oversized textures or meshes usually appear as GPU or memory problems, so trace them back to assets. In shared experiences, code that waits on network responses can cause stalls that look like CPU hitches even though the render cost is unchanged. Separate the two by checking whether the stall coincides with network activity. Multi-user performance has more to it than this article covers.&lt;/p&gt;

&lt;h2&gt;
  
  
  Change one thing at a time
&lt;/h2&gt;

&lt;p&gt;Meta's PC VR guidelines advise changing one thing at a time while optimizing. Bottlenecks also move: in Meta's workflow an app that was CPU-bound can become fragment-bound once the CPU work is fixed, and a single fix rarely reaches the target. Re-run the classification after every change.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;A hypothetical reading of the flow&lt;/em&gt;: suppose frame times exceed the budget only when many objects are in view, and the render-nothing test barely changes the result. That points to CPU-bound work. The next question is which thread, then which function on that thread. The scenario is illustrative, not a measured case.&lt;/p&gt;

&lt;h2&gt;
  
  
  Symptoms and where to look
&lt;/h2&gt;

&lt;p&gt;These are starting hypotheses, not diagnoses.&lt;/p&gt;

&lt;h3&gt;
  
  
  Constant overruns in busy scenes
&lt;/h3&gt;

&lt;p&gt;When overruns remain constant during busy scenes, the likely class is a bottleneck in the GPU (vertex) or the CPU render thread.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What to check: Engineers must evaluate the draw-call count, triangle count, and active render stages.&lt;/li&gt;
&lt;li&gt;Typical levers: Performance can be restored by implementing LOD, culling, batching, and utilizing simpler meshes.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Overruns that grow with screen coverage or effects
&lt;/h3&gt;

&lt;p&gt;Performance drops that scale directly with screen coverage point to a GPU (fragment) issue.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What to check: Technical leads must evaluate the overall shader cost, pixel overdraw, and rendering resolution.&lt;/li&gt;
&lt;li&gt;Typical levers: Teams should deploy cheaper shaders, use fewer transparent layers, and lower the internal render scale.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Periodic hitches Stuttering or periodic hitches are typically tied to CPU processing or memory limits.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What to check: Profiling should isolate garbage collection spikes, asset loading times, and background streaming data.&lt;/li&gt;
&lt;li&gt;Typical levers: Organizations can resolve these drops by instituting strict object pooling and reuse strategies, alongside proactive pre-loading.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Smooth at first, worse after a long session
&lt;/h3&gt;

&lt;p&gt;When performance degrades over an extended period, the root cause is thermal throttling.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What to check: Monitoring must track refresh-rate drops and hardware clock changes over time.&lt;/li&gt;
&lt;li&gt;Typical levers: Mitigate this by lowering the baseline target rate and systematically reducing the sustained processing load.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Crashes or restarts in heavy scenes
&lt;/h3&gt;

&lt;p&gt;Sudden application crashes or restarts in dense environments indicate severe memory exhaustion.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What to check: Engineers must measure peak memory allocation strictly against the hard device limit.&lt;/li&gt;
&lt;li&gt;Typical levers: Prevent these failures by enforcing texture and mesh budgets and aggressively unloading unused assets.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Stalls only in multi-user sessions
&lt;/h3&gt;

&lt;p&gt;Stalls occurring exclusively in multiplayer environments stem from network or CPU synchronization issues.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What to check: Development teams must profile the exact timing of waits on network calls.&lt;/li&gt;
&lt;li&gt;Typical levers: Stabilize the session by using asynchronous handling and enforcing smaller state updates between clients.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  A one-page diagnostic flow
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;Target set?          -&amp;gt; Name device, refresh rate, budget (ms).&lt;/li&gt;
&lt;li&gt;Measured on device?  -&amp;gt; No: stop. Build, deploy, capture first.&lt;/li&gt;
&lt;li&gt;Over budget?         -&amp;gt; No: done; add to baseline.
                       Yes: constant, or spikes?&lt;/li&gt;
&lt;li&gt;Constant overruns    -&amp;gt; CPU or GPU bound? (render-nothing test, CPU/GPU levels)
 CPU-bound          -&amp;gt; main thread or render thread? -&amp;gt; function-level trace.
 GPU-bound          -&amp;gt; vertex or fragment? -&amp;gt; GPU capture, draw calls.&lt;/li&gt;
&lt;li&gt;Spikes               -&amp;gt; GC, loading, streaming, network waits?&lt;/li&gt;
&lt;li&gt;Long session worse?  -&amp;gt; memory growth or thermal throttling?&lt;/li&gt;
&lt;li&gt;Change ONE thing     -&amp;gt; re-capture -&amp;gt; re-classify -&amp;gt; repeat.&lt;/li&gt;
&lt;li&gt;Hit target?          -&amp;gt; Save the capture as the new baseline.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Turn the result into a regression check
&lt;/h2&gt;

&lt;p&gt;A fix that is not guarded will not last. Keep a baseline capture per release and compare each new build with it. Per-frame times exported from your capture tool can be summarized with a small script. The one below assumes a CSV with a column of frame times in milliseconds. Adjust the column name to match your export. It converts the refresh rate into a budget and reports how many frames exceeded it.&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="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;csv&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;sys&lt;/span&gt;


&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;load_frame_times_ms&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;column&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;with&lt;/span&gt; &lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;newline&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;""&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nf"&gt;float&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;row&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;column&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;row&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;csv&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;DictReader&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)]&lt;/span&gt;


&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;percentile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;sorted_vals&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;idx&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;round&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="mi"&gt;100&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;sorted_vals&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;sorted_vals&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nf"&gt;max&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nf"&gt;min&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;sorted_vals&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;idx&lt;/span&gt;&lt;span class="p"&gt;))]&lt;/span&gt;


&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;summarize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;frame_ms&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;refresh_hz&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;budget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mf"&gt;1000.0&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="n"&gt;refresh_hz&lt;/span&gt;
    &lt;span class="n"&gt;ordered&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;sorted&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;frame_ms&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;over&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;sum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;frame_ms&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;budget&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;budget_ms&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;round&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;budget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;frames&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;frame_ms&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;pct_over_budget&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;round&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;100&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;over&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="nf"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;frame_ms&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;p95_ms&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;round&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;percentile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ordered&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;95&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;p99_ms&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;round&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;percentile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ordered&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;99&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;worst_ms&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;round&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ordered&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&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;__name__&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;__main__&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;column&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;hz&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;sys&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="n"&gt;sys&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="nf"&gt;float&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;sys&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
    &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;summarize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;load_frame_times_ms&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;column&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;hz&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="c1"&gt;# Example team-defined gate (not a platform rule): tune it to your project.
&lt;/span&gt;    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;pct_over_budget&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mf"&gt;1.0&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;sys&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;exit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;FAIL: too many frames over budget&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Two limits apply. First, a frame whose total time exceeds the budget is a proxy for a missed frame, because CPU and GPU work can overlap across frames. Prefer your tool's own missed-frame or app-frame-rate statistics where it provides them. Second, the pass/fail threshold is yours to set, not a platform rule.&lt;/p&gt;

&lt;h2&gt;
  
  
  A note on evaluating this skill in candidates
&lt;/h2&gt;

&lt;p&gt;The workflow above is also a good test of profiling skill. For a short guide to &lt;a href="https://techhub.asia/hire-vr-developers/" rel="noopener noreferrer"&gt;screening VR developers on profiling skills&lt;/a&gt; as part of a wider hiring process, see TechHub Asia's overview. A strong answer to a frame-drop question starts with measurement on the target device, separates CPU, GPU, memory and content causes, changes one variable at a time and ends with a regression check. A weak answer jumps straight to a favorite optimization.&lt;/p&gt;

&lt;h2&gt;
  
  
  Checklist
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Is the target device, refresh rate and frame budget written down?&lt;/li&gt;
&lt;li&gt;Was the measurement taken on the device with a development build?&lt;/li&gt;
&lt;li&gt;Does every capture use the same repeatable scenario?&lt;/li&gt;
&lt;li&gt;Did you classify CPU- vs GPU-bound before optimizing?&lt;/li&gt;
&lt;li&gt;Did you check a sustained session for thermal and memory effects?&lt;/li&gt;
&lt;li&gt;Did you change one thing and re-capture?&lt;/li&gt;
&lt;li&gt;Is the final capture saved as a baseline with a pass/fail check?&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>vr</category>
      <category>gamedev</category>
      <category>performance</category>
      <category>discuss</category>
    </item>
    <item>
      <title>How to Integrate AI Vision Into an Existing Production Line</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Tue, 27 Oct 2026 07:39:57 +0000</pubDate>
      <link>https://dev.to/techhub_admin/how-to-integrate-ai-vision-into-an-existing-production-line-4lfp</link>
      <guid>https://dev.to/techhub_admin/how-to-integrate-ai-vision-into-an-existing-production-line-4lfp</guid>
      <description>&lt;p&gt;To integrate AI vision and robotics into an existing production line, add the system as a module instead of redesigning the line. Define the problem and the current operating costs, assess the factory environment, test the system in offline simulation, pass a factory acceptance test (FAT), run a pilot, then move to production, with the shutdown window planned in advance.&lt;/p&gt;

&lt;p&gt;This sequence comes from Lê Thái Sơn, Project Manager at Solomon Technology Corp., who has worked for ten years on AI vision and robotics for factory automation. He discusses it in the Q&amp;amp;A of the podcast episode &lt;a href="https://youtu.be/Y1VbLuCYSQI" rel="noopener noreferrer"&gt;AI-Powered Robotics: How Physical AI &amp;amp; Embodied AI Will Transform How We Live and Work&lt;/a&gt;. This guide organizes his answers into a practical path and notes where the episode gives no detail.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why integration is usually modular
&lt;/h2&gt;

&lt;p&gt;Most businesses do not build new factories from scratch, and Sơn says most AI vision and robotics systems are built as modules. A module is built into the factory's existing production line. It is rarely the case, he says, that a factory completely redesigns its layout or production process to accommodate the system being added.&lt;/p&gt;

&lt;p&gt;That shapes the whole approach: the new system has to fit what is already running.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 1: Define the problem and your current operating costs
&lt;/h3&gt;

&lt;p&gt;Before choosing technology, Sơn's advice is to start with the customer's actual problem, not with "What can we do with AI?"&lt;/p&gt;

&lt;p&gt;Costs come next. For the process being replaced, he suggests looking at what the factory currently spends on:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;labor&lt;/li&gt;
&lt;li&gt;electricity (power consumption)&lt;/li&gt;
&lt;li&gt;operation and maintenance&lt;/li&gt;
&lt;li&gt;material wear and consumables&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These figures give the actual current operating cost. Sơn is open about the difficulty: estimating payback is hard because AI and robotics projects come with high costs. The episode gives no payback benchmark or timeline, and this guide does not either.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 2: Assess the factory environment
&lt;/h3&gt;

&lt;p&gt;Sơn recommends looking at real conditions in advance, not relying on lab results. The factors he lists are temperature, humidity, dust, smoke, vibration and surrounding magnetic fields. He adds that there is a lot to consider, and that the more of it a team can anticipate, the more it can reduce the cost and risk of deploying an AI system in a factory.&lt;/p&gt;

&lt;p&gt;The reason is that conditions in a factory differ from the lab. In the main talk, he says lighting may change, cameras may vibrate, the environment may be dusty, products may vary, and conveyor speed may not be constant.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 3: Test in offline simulation
&lt;/h3&gt;

&lt;p&gt;Offline simulation, in Sơn's description, means testing the system separately first. It connects to the idea of a digital twin: running the system in a simulation that reflects real-world conditions. Once a problem is solved in simulation, he says, deploying in the real world involves far less risk.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 4: Run a factory acceptance test (FAT)
&lt;/h3&gt;

&lt;p&gt;A FAT is a factory acceptance test. Its purpose, per Sơn, is to ensure the system operates reliably before it is integrated into the production line.&lt;/p&gt;

&lt;h3&gt;
  
  
  Step 5: Pilot, then production
&lt;/h3&gt;

&lt;p&gt;Sơn names the pilot and production as the final two stages. He does not describe them in detail, so this guide does not either. What the pilot should measure, and for how long, depends on the line and is best agreed with the team doing the integration. That last point is my suggestion, not his.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Offline simulation: Test the system separately first&lt;/li&gt;
&lt;li&gt;Factory acceptance test (FAT): Confirm the system operates reliably before integration into the line&lt;/li&gt;
&lt;li&gt;Pilot: Named as a stage; not detailed&lt;/li&gt;
&lt;li&gt;Production: Named as the final stage; not detailed&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Plan the production shutdown
&lt;/h2&gt;

&lt;p&gt;Sơn also notes that the time needed to deploy the system on the line has to be estimated, so the factory can plan an appropriate production shutdown. His broader point, in answer to a question about avoiding extended downtime, is that the staged approach above is how a team gets to a predictable deployment window.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where to start: small problems with clear value
&lt;/h2&gt;

&lt;p&gt;Sơn advises starting with small problems that deliver clear value. One example he gives: a process that needs five workers to inspect products could use AI to support inspection of product appearance and other easy-to-detect characteristics, with a low risk of error. Fewer workers, perhaps two, could handle that part, and the rest would take on more detailed inspections. Another is loading products into CNC or cutting machines, where accidents occur frequently. The five-to-two figure is an illustration and not a reported result.&lt;/p&gt;

&lt;h2&gt;
  
  
  Mistakes to avoid
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Chasing trends. In Sơn's view, the biggest mistake in moving from traditional automation to AI robotics is adopting AI because competitors have it. The question should be whether the system solves staffing and efficiency problems and generates economic value.&lt;/li&gt;
&lt;li&gt;Over-focusing on model accuracy. A claim like "my model achieves 99%" describes ideal conditions, he says. Plan for the actual factory conditions instead.&lt;/li&gt;
&lt;li&gt;Investing in humanoid robots too early. He suggests continuing to invest in conventional robotics for now. Humanoids cannot yet meet high production speeds, and keeping them stable is difficult. This is his view of present conditions.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  How long does it take to recover the investment in AI vision and robotics?
&lt;/h3&gt;

&lt;p&gt;The episode gives no timeline. Sơn says payback is difficult to estimate because these projects cost a lot. His starting point is to calculate current operating costs for the process being replaced, covering labor, electricity, operation and maintenance, and material wear and consumables.&lt;/p&gt;

&lt;h3&gt;
  
  
  Can AI vision be added without redesigning the production line?
&lt;/h3&gt;

&lt;p&gt;According to Sơn, yes, in most cases. These systems are generally built as modules that fit into the existing line, and factories rarely redesign their layout or process to accommodate them.&lt;/p&gt;

&lt;h3&gt;
  
  
  What should be tested before the system goes into production?
&lt;/h3&gt;

&lt;p&gt;He lists offline simulation, a factory acceptance test (FAT), and a pilot before production. Offline simulation tests the system separately, and the FAT confirms reliable operation before integration.&lt;/p&gt;

&lt;h3&gt;
  
  
  Should factories invest in humanoid robots now?
&lt;/h3&gt;

&lt;p&gt;Not yet, in Sơn's view. He recommends continuing to invest in conventional robotics and integrating newer technologies gradually as they develop.&lt;/p&gt;

&lt;h2&gt;
  
  
  Source
&lt;/h2&gt;

&lt;p&gt;This article is based on Lê Thái Sơn's Q&amp;amp;A and talk in the podcast episode &lt;a href="https://youtu.be/Y1VbLuCYSQI" rel="noopener noreferrer"&gt;&lt;em&gt;AI-Powered Robotics: How Physical AI &amp;amp; Embodied AI Will Transform How We Live and Work&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>robotics</category>
      <category>automation</category>
      <category>discuss</category>
    </item>
    <item>
      <title>Unity or Unreal for Your VR Project: A Decision Framework</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Thu, 22 Oct 2026 10:21:06 +0000</pubDate>
      <link>https://dev.to/techhub_asia/unity-or-unreal-for-your-vr-project-a-decision-framework-15nl</link>
      <guid>https://dev.to/techhub_asia/unity-or-unreal-for-your-vr-project-a-decision-framework-15nl</guid>
      <description>&lt;p&gt;Choosing between Unity and Unreal Engine for a VR project is a constraint-matching exercise, not a popularity contest. Work through the target device, your team's skills and existing code, the visual requirements, SDK and plugin dependencies, licensing and long-term maintenance, then let a time-boxed prototype on the real headset settle any tie. Meta's quick start guide lists Unity (C#) and Unreal Engine (C++ or Blueprints) as the paths for games and immersive experiences, plus native OpenXR for maximum control. That means "can it run on the headset" rarely eliminates either engine. The other questions do.&lt;/p&gt;

&lt;p&gt;This guide is for engineering leads and technical founders making the call, and for non-technical stakeholders who need to review it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is not in doubt
&lt;/h2&gt;

&lt;p&gt;Both engines are supported ways to build for Quest. Meta has said that, from its v74 SDK, the built-in OpenXR path in Unity, Unreal and Godot is a recommended route, with Meta plugins available for features specific to Horizon OS. For Unity, Meta reported that Unity's OpenXR Plugin 1.14 reached feature and performance parity with the Oculus XR plugin.&lt;/p&gt;

&lt;p&gt;So portability and platform support are broadly similar on paper. Check each engine's current documentation for every platform you target, because support changes between releases. The differences that decide a project sit in the six factors below.&lt;/p&gt;

&lt;h2&gt;
  
  
  Factor 1: Target device
&lt;/h2&gt;

&lt;p&gt;Start with the hardware, because it sets the budget everything else has to fit inside. Quest headsets are standalone, wireless devices that need no PC. A standalone build therefore runs under the device's own CPU, GPU, thermal and memory limits. Meta documents per-app memory kill limits of 4.4 GiB on Quest 2 and Quest Pro and 5.75 GiB on Quest 3, Quest 3S and Meta VR Glasses. A PC-tethered headset borrows the PC's GPU and has different constraints.&lt;/p&gt;

&lt;p&gt;A common pattern is Unity for standalone work and Unreal for PC-tethered, high-fidelity work. Treat that as a starting hypothesis, not a rule. Neither engine removes standalone constraints, and you should confirm the choice on the actual target device.&lt;/p&gt;

&lt;h2&gt;
  
  
  Factor 2: Team skills and existing code
&lt;/h2&gt;

&lt;p&gt;The engine decides which language your team works in every day.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Unity projects are written in C#.&lt;/li&gt;
&lt;li&gt;Unreal projects combine C++ with Blueprint, its visual scripting system. Blueprint speeds up iteration, but a team still needs a rule for when logic moves to native C++ for maintainability or performance.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If your team already ships in one engine, the switching cost is usually larger than the difference between the engines for your use case. Count onboarding time, tooling, build pipelines and code-review practice. For Blueprint-heavy projects, also decide how graphs are reviewed and versioned, since visual assets are reviewed differently from code.&lt;/p&gt;

&lt;h2&gt;
  
  
  Factor 3: Visual requirements
&lt;/h2&gt;

&lt;p&gt;Write the visual target as something testable, not as "high quality." For example: a named scene with specific materials, lighting and object counts that must hold the target frame rate on the target headset. Then build that scene, or the worst-case version of it, in the engines still in contention. Claims that one engine "looks better" mean little until the scene runs on your device.&lt;/p&gt;

&lt;h2&gt;
  
  
  Factor 4: SDK and plugin dependencies
&lt;/h2&gt;

&lt;p&gt;List everything the project depends on beyond the engine:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The headset SDK or OpenXR path&lt;/li&gt;
&lt;li&gt;The interaction framework&lt;/li&gt;
&lt;li&gt;Networking, if the experience is shared&lt;/li&gt;
&lt;li&gt;Authentication and enterprise integrations&lt;/li&gt;
&lt;li&gt;Analytics and content tooling&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For each item, confirm it supports the engine and version you plan to use. A single indispensable plugin that exists for only one engine can override every other consideration.&lt;/p&gt;

&lt;p&gt;Also be explicit about which layer is portable. OpenXR provides a cross-platform path, but Horizon OS-specific features are reached through extensions and Meta's platform plugins, so a "cross-platform" app may still carry vendor-specific code.&lt;/p&gt;

&lt;h2&gt;
  
  
  Factor 5: Licensing
&lt;/h2&gt;

&lt;p&gt;Licensing is time-sensitive. The terms below were taken from the vendors' pages in October 2026. Re-check them before you decide, and ask your own advisers how they apply to you.&lt;/p&gt;

&lt;p&gt;Unity ties its plans to revenue and funding:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Personal is for customers with up to $200,000 in revenue and funding.&lt;/li&gt;
&lt;li&gt;Pro is required above that, and Enterprise is required for businesses with more than $25 million in annual revenue.&lt;/li&gt;
&lt;li&gt;A detail that matters if you outsource: Unity's terms say a small business providing services to others is eligible for Personal only if its clients, in aggregate, are under the $200K threshold.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Unreal Engine uses a different structure:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;It is free for individuals and small businesses under $1 million in annual gross revenue, and for games it charges a 5% royalty on lifetime gross revenue above $1 million.&lt;/li&gt;
&lt;li&gt;A non-game application that relies on engine code at runtime and is licensed to third-party end users also falls under the royalty model.&lt;/li&gt;
&lt;li&gt;Other commercial use by a company with more than $1 million in revenue over the past 12 months needs a seat license, listed at $1,850 per seat per year.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The practical question for a hired team is whose licence covers the developers. Settle that with the vendor and your contractor before work starts, not after.&lt;/p&gt;

&lt;h2&gt;
  
  
  Factor 6: Maintenance and upgrades
&lt;/h2&gt;

&lt;p&gt;VR tooling moves quickly, so plan for the project's second year at the start:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Pin the engine version. For Unity, Meta's quick start guide lists Unity 2022.3 LTS or later; check the current requirement before you start.&lt;/li&gt;
&lt;li&gt;Schedule upgrades. After each upgrade, re-run your performance and interaction tests on the device, because a plugin update can break a build that passed last month.&lt;/li&gt;
&lt;li&gt;Know your source-code position. Meta notes that Unreal's source code access lets developers modify either development path. Unity lists source code access under its Enterprise plan. Decide whether you could ever need engine-level changes, and what that would cost you.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Three illustrative scenarios
&lt;/h2&gt;

&lt;p&gt;These are hypothetical. They show how the factors combine, not what your project should choose.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Standalone training app, small team with C# experience. Device limits and team skills dominate, so the lean is toward the engine your team already knows. Prototype the heaviest scene on the headset before committing.&lt;/li&gt;
&lt;li&gt;PC-tethered visualization where visual fidelity is the product. Rendering requirements carry the most weight. If the team has C++ experience, Unreal may fit, but prove the visual target on real hardware first.&lt;/li&gt;
&lt;li&gt;One product across several headsets. Both engines have OpenXR paths, so the decision comes down to plugin and SDK coverage for each platform and to the team. Build a comparison table of every required plugin.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  A weighted decision matrix
&lt;/h2&gt;

&lt;p&gt;Use a matrix when the factors pull in different directions:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Set hard gates first. A hard requirement, such as a plugin that exists in only one engine, excludes an option before any scoring.&lt;/li&gt;
&lt;li&gt;Weight the six factors so the weights add up to 100. Weights reflect your project. The ones below are only an example.&lt;/li&gt;
&lt;li&gt;Score each remaining engine from 1 to 5 using evidence: prototype results, documentation checks, a team skills review. Gut feeling is not evidence.&lt;/li&gt;
&lt;li&gt;Multiply, sum and discuss. A narrow gap means the decision rests on a factor you may have mis-scored, so revisit that one.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The script below shows the arithmetic. The engine names and scores are made up for illustration and say nothing about either real engine.&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="n"&gt;WEIGHTS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;device_fit&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;25&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;team_skills&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;20&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;visual_requirements&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;15&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;sdk_plugin_coverage&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;15&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;licensing&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;maintenance&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;15&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="nf"&gt;sum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;WEIGHTS&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;values&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;total&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;scores&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;sum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;WEIGHTS&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;scores&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;k&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;WEIGHTS&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt;

&lt;span class="c1"&gt;# Illustrative numbers only: replace with evidence from your own project.
&lt;/span&gt;&lt;span class="n"&gt;candidates&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Engine A&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;passes_gates&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;scores&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;device_fit&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;team_skills&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;visual_requirements&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                   &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;sdk_plugin_coverage&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;licensing&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;maintenance&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;
    &lt;span class="p"&gt;},&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Engine B&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;passes_gates&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;scores&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;device_fit&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;team_skills&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;visual_requirements&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                   &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;sdk_plugin_coverage&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;licensing&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;maintenance&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;3&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="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;candidates&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;items&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;passes_gates&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;]:&lt;/span&gt;
        &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s"&gt;: excluded by a hard requirement&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s"&gt;: &lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;total&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;scores&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;&lt;span class="si"&gt;:&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="c1"&gt;# Engine A: 3.95
# Engine B: 3.25
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  What the choice means for hiring
&lt;/h2&gt;

&lt;p&gt;The engine you choose shapes the role you write. A Unity project calls for C#, the engine's XR packages and rendering pipelines. An Unreal project calls for C++, Blueprint architecture and Unreal's memory model. Name the engine, its version and the target headset in the role description. For more on hiring VR developers by engine and device, including the wider process of defining roles and evaluating candidates, see TechHub Asia's guide.&lt;/p&gt;

&lt;h2&gt;
  
  
  A short checklist before you decide
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Is the target headset named, and is it standalone or PC-tethered?&lt;/li&gt;
&lt;li&gt;Can your team maintain code in the engine's language for the life of the product?&lt;/li&gt;
&lt;li&gt;Have you run your heaviest scene on the real device in each remaining option?&lt;/li&gt;
&lt;li&gt;Does every required plugin support the engine and version you chose?&lt;/li&gt;
&lt;li&gt;Have you confirmed the licence terms against your actual revenue and who will use the engine?&lt;/li&gt;
&lt;li&gt;Do you have a plan for engine upgrades?
If you can answer all six, the matrix will mostly confirm what you already know.&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>vr</category>
      <category>gamedev</category>
      <category>unity3d</category>
      <category>discuss</category>
    </item>
    <item>
      <title>A Good Model Is Not a Good System: What Changes When AI Vision Leaves the Lab</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Fri, 16 Oct 2026 03:38:46 +0000</pubDate>
      <link>https://dev.to/techhub_asia/a-good-model-is-not-a-good-system-what-changes-when-ai-vision-leaves-the-lab-3e1n</link>
      <guid>https://dev.to/techhub_asia/a-good-model-is-not-a-good-system-what-changes-when-ai-vision-leaves-the-lab-3e1n</guid>
      <description>&lt;p&gt;A vision model that performs well in a demo has solved one part of the problem. Lê Thái Sơn, Project Manager at Solomon Technology Corp., calls the rest "industrial AI engineering," and he says it is the major difference between that field and AI research. He has worked for ten years on AI vision and robotics for factory automation.&lt;/p&gt;

&lt;p&gt;His talk in the episode AI-Powered Robotics: How Physical AI &amp;amp; Embodied AI Will Transform How We Live and Work contains no code, framework names or benchmarks. What it offers is a systems-level view of why models that look good in demos struggle on factory floors. This article summarizes that view for engineers. Anything that goes beyond the episode is marked as my own framing.&lt;/p&gt;

&lt;h2&gt;
  
  
  The pipeline: perception, cognition, action
&lt;/h2&gt;

&lt;p&gt;Sơn's example is a robot picking from a bin of mixed products:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;A camera captures image data, and a 3D camera gathers additional visual information.&lt;/li&gt;
&lt;li&gt;AI identifies which objects can be picked.&lt;/li&gt;
&lt;li&gt;A computing system determines their positions and orientations.&lt;/li&gt;
&lt;li&gt;The robot selects a suitable trajectory, picks the product and places it in the required location.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;He describes this as three key components: perception, cognition and action, or simply seeing, understanding and acting. He calls that the foundation of embodied AI. Throughout the talk, the unit he evaluates is this whole chain, not any single stage.&lt;/p&gt;

&lt;h2&gt;
  
  
  What changes outside the lab
&lt;/h2&gt;

&lt;p&gt;Sơn's illustration is a lab system with accuracy of around 80–90%, where "the demo looks great." In the factory, he says, the situation is completely different:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Lighting changes.&lt;/li&gt;
&lt;li&gt;The camera vibrates.&lt;/li&gt;
&lt;li&gt;The environment is dusty.&lt;/li&gt;
&lt;li&gt;Products vary, with scratches or deformation.&lt;/li&gt;
&lt;li&gt;Conveyor speed is not constant.&lt;/li&gt;
&lt;li&gt;A product appears that was not in the original dataset.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;From this he draws a conclusion: "a good AI model does not necessarily make a good automation system." The Q&amp;amp;A repeats the point from another angle. Claiming "My model achieves 99%," he says, is one of the most common mistakes, because that figure holds under ideal conditions.&lt;/p&gt;

&lt;p&gt;In ML terms, and this is my framing, most items on the list are variations in the input data. They include shifted lighting, noise from vibration and dust, out-of-distribution products, and timing that changes with line speed. The model's inputs are no longer controlled, so the accuracy measured on a clean dataset is not the number that matters in production.&lt;/p&gt;

&lt;h2&gt;
  
  
  The questions that belong in the design review
&lt;/h2&gt;

&lt;p&gt;Sơn gives a set of system-level questions that go beyond accuracy:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Is the camera stable?&lt;/li&gt;
&lt;li&gt;Is the lighting controlled?&lt;/li&gt;
&lt;li&gt;Can processing keep up with the cycle time?&lt;/li&gt;
&lt;li&gt;Can the robot pick reliably?&lt;/li&gt;
&lt;li&gt;If the AI is uncertain, how will the system respond?&lt;/li&gt;
&lt;li&gt;What happens if the camera loses its connection?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Grouped by concern (again my framing), these cover sensing stability, timing, actuation reliability, and behavior under uncertainty and failure. Only the first group is about the model, and it is the one with the least say in the last two.&lt;/p&gt;

&lt;h2&gt;
  
  
  Latency, cycle time and the edge
&lt;/h2&gt;

&lt;p&gt;Sơn lists computing power as one of the reasons Physical AI has become practical. Many AI tasks once had to run on large server systems, he says. Today they can run on small devices, including edge devices, with edge AI operating directly on the factory floor at very low latency.&lt;/p&gt;

&lt;p&gt;That connects to his cycle-time question. My reading is that where inference runs is therefore a design decision tied to how fast the line moves. The episode does not go further than this, and it gives no latency figures.&lt;/p&gt;

&lt;h2&gt;
  
  
  Fix the setup before the model
&lt;/h2&gt;

&lt;p&gt;The same hypothetical from the talk applies here: a one-point accuracy gain, from 95% to 96%, might require a very large GPU system and more complex servicing and maintenance. Sơn contrasts that with improvements to the traditional setup, such as redesigning the lighting, changing the camera position or improving the mechanical setup, which may be much better and far more stable. His practical rule is to ask what the customer's actual problem is before deciding whether to improve the AI or the engineering around it.&lt;/p&gt;

&lt;p&gt;For engineers, the useful reading is that sensing and mechanics belong to the input pipeline. They are not background conditions to work around.&lt;/p&gt;

&lt;h2&gt;
  
  
  Keep traditional automation in the loop
&lt;/h2&gt;

&lt;p&gt;Sơn argues for balance, not replacement. Traditional automation, he says, must keep providing stability and reliability, while the AI contributes its adaptive capabilities. A system that only does what it was programmed to do struggles when products sit in random positions, vary in shape, or arrive in jumbled arrangements. AI vision helps there. Conventional PLC and industrial-robot control remains what makes the system dependable.&lt;/p&gt;

&lt;h2&gt;
  
  
  Simulate before you deploy
&lt;/h2&gt;

&lt;p&gt;Digital twins and simulation appear in both parts of the episode. In the talk, Sơn says robot simulation platforms let teams build virtual factories, train robots and test AI algorithms before deployment, which helps with stability and safety. In the Q&amp;amp;A he describes running the system in a simulation that reflects real-world conditions: once a problem is solved there, deploying in the real world carries far less risk.&lt;/p&gt;

&lt;p&gt;He also recommends assessing the real environment in advance, covering temperature, humidity, dust, smoke, vibration and surrounding magnetic fields. In his words, the more that can be anticipated, the more the cost and risk of deployment can be reduced.&lt;/p&gt;

&lt;h2&gt;
  
  
  A note on skills
&lt;/h2&gt;

&lt;p&gt;Sơn's advice to young engineers is practical: "Do not learn AI only through a computer screen." He suggests connecting AI to peripheral devices such as cameras, sensors and motors, and programming and controlling a robotic system or a sensor system running on a device. Only then, he says, will you see "the huge gap between 'the model works' and 'the system works.'"&lt;/p&gt;

&lt;p&gt;In the Q&amp;amp;A he adds that engineers should broaden out from a single specialty. They should understand hardware, software, cloud, servers, databases and front-end and back-end development, and he notes that they can learn all of this with AI right now.&lt;/p&gt;

&lt;h2&gt;
  
  
  The takeaway
&lt;/h2&gt;

&lt;p&gt;The episode's engineering argument comes down to a change of unit. The thing to evaluate is the whole chain, from sensor to actuator, including what happens when something goes wrong. Model accuracy is one input to that evaluation.&lt;br&gt;
&lt;a href="https://youtu.be/Y1VbLuCYSQI" rel="noopener noreferrer"&gt;Watch the full episode with Lê Thái Sơn&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>robotics</category>
      <category>automation</category>
      <category>computervision</category>
    </item>
    <item>
      <title>Android Kotlin Developer vs Backend Kotlin Developer: How to Hire the Right One</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Mon, 28 Sep 2026 08:45:04 +0000</pubDate>
      <link>https://dev.to/techhub_asia/android-kotlin-developer-vs-backend-kotlin-developer-how-to-hire-the-right-one-18i8</link>
      <guid>https://dev.to/techhub_asia/android-kotlin-developer-vs-backend-kotlin-developer-how-to-hire-the-right-one-18i8</guid>
      <description>&lt;p&gt;Kotlin is a single language, but the job of a Kotlin developer changes completely depending on where the code runs. An Android Kotlin developer builds user-facing mobile apps. A backend Kotlin developer builds the services those apps call. Both write Kotlin, and neither is a substitute for the other.&lt;/p&gt;

&lt;p&gt;The main difference between an Android Kotlin developer and a backend Kotlin developer is the runtime and the frameworks they work with. Android developers work with the Android SDK, Jetpack Compose, and device lifecycles. Backend developers work with server frameworks such as Spring Boot, Ktor, or Quarkus, and with the databases, APIs, and infrastructure behind them. Hiring the wrong one is a common and expensive mistake, so this guide explains how to tell them apart and which one your project needs.&lt;/p&gt;

&lt;p&gt;If you're building a full evaluation process, the seniority matrix in our Kotlin hiring guide shows how to match experience level to project complexity.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why Kotlin Gets Confused with "Android Development"
&lt;/h2&gt;

&lt;p&gt;Kotlin became Google's recommended language for Android development, which is why many people assume Kotlin and Android are the same thing. They aren't. Kotlin is a general-purpose, statically typed language developed by JetBrains, and it runs on the JVM, in Android apps, and in Kotlin Multiplatform projects.&lt;/p&gt;

&lt;p&gt;This confusion leads to a specific hiring error: a company hires a strong backend engineer to build a mobile app, or hires an Android specialist to design a high-throughput API. Each developer may be excellent, but the skills don't transfer as cleanly as the shared language suggests.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Android Kotlin Developers Actually Do
&lt;/h2&gt;

&lt;p&gt;An Android Kotlin developer builds and maintains the mobile client. Their work is shaped by the constraints of a device: screen lifecycles, configuration changes such as rotation, limited memory, background execution rules, and a UI that must stay responsive.&lt;/p&gt;

&lt;p&gt;A typical Android stack includes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Jetpack Compose for declarative UI&lt;/li&gt;
&lt;li&gt;ViewModel and StateFlow for holding UI state across lifecycle events&lt;/li&gt;
&lt;li&gt;Room for local persistence&lt;/li&gt;
&lt;li&gt;Hilt or Dagger for dependency injection&lt;/li&gt;
&lt;li&gt;JUnit, MockK, and Espresso for unit, mocking, and UI tests&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Here is a simplified example of the state-holding pattern an Android developer would write:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight kotlin"&gt;&lt;code&gt;&lt;span class="nd"&gt;@HiltViewModel&lt;/span&gt;
&lt;span class="kd"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;OrdersViewModel&lt;/span&gt; &lt;span class="nd"&gt;@Inject&lt;/span&gt; &lt;span class="k"&gt;constructor&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="py"&gt;orderRepository&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;OrderRepository&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ViewModel&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="py"&gt;_state&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;MutableStateFlow&lt;/span&gt;&lt;span class="p"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;OrdersUiState&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;(&lt;/span&gt;&lt;span class="nc"&gt;OrdersUiState&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Loading&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="py"&gt;state&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;StateFlow&lt;/span&gt;&lt;span class="p"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;OrdersUiState&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="n"&gt;_state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;asStateFlow&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;

    &lt;span class="nf"&gt;init&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;viewModelScope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;launch&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;_state&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="k"&gt;try&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
                &lt;span class="nc"&gt;OrdersUiState&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Success&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;orderRepository&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;fetchOrders&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
            &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;catch&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Exception&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
                &lt;span class="nc"&gt;OrdersUiState&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;message&lt;/span&gt; &lt;span class="o"&gt;?:&lt;/span&gt; &lt;span class="s"&gt;"Unknown error"&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="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The important detail is what the code protects against. &lt;code&gt;viewModelScope&lt;/code&gt; ties the work to the ViewModel's lifecycle, and &lt;code&gt;StateFlow&lt;/code&gt; lets the UI survive rotation without refetching from scratch. An Android developer who understands this pattern is thinking about the device, not only the syntax.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Backend Kotlin Developers Actually Do
&lt;/h2&gt;

&lt;p&gt;A backend Kotlin developer builds services, APIs, and the systems that store and process data. Their concerns are throughput, correctness under concurrency, security, observability, and deployment. They rarely think about screen rotation, but they think a great deal about what happens when a database call times out under load.&lt;/p&gt;

&lt;p&gt;A typical backend stack includes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Spring Boot or Ktor for the application framework&lt;/li&gt;
&lt;li&gt;API design for REST or other service interfaces&lt;/li&gt;
&lt;li&gt;Persistence for relational or document databases&lt;/li&gt;
&lt;li&gt;Security for authentication, authorization, and data handling&lt;/li&gt;
&lt;li&gt;Observability through logging, metrics, and tracing&lt;/li&gt;
&lt;li&gt;Containers and cloud deployment for production operations&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A minimal Ktor route shows the shape of the work:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight kotlin"&gt;&lt;code&gt;&lt;span class="k"&gt;fun&lt;/span&gt; &lt;span class="nc"&gt;Application&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;module&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nf"&gt;install&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;ContentNegotiation&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nf"&gt;json&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="nf"&gt;routing&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"/orders/{id}"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="py"&gt;id&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;parameters&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;"id"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
                &lt;span class="o"&gt;?:&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt;&lt;span class="nd"&gt;@get&lt;/span&gt; &lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;respond&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;HttpStatusCode&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;BadRequest&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

            &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="py"&gt;order&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="n"&gt;orderService&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;find&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                &lt;span class="o"&gt;?:&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt;&lt;span class="nd"&gt;@get&lt;/span&gt; &lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;respond&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;HttpStatusCode&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;NotFound&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

            &lt;span class="n"&gt;call&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;respond&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;order&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Notice that the code focuses on request validation and response semantics. A backend developer who only knows Kotlin syntax may write this route, but a strong one also considers timeouts, connection pooling, authentication on the route, and how this endpoint behaves during a deployment.&lt;/p&gt;

&lt;h2&gt;
  
  
  Comparison Table
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxw7g34ep8t6rlnsehlbp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxw7g34ep8t6rlnsehlbp.png" alt="A comparison table detailing the technical differences between Android Kotlin Developers and Backend Kotlin Developers" width="522" height="375"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Can One Developer Do Both?
&lt;/h2&gt;

&lt;p&gt;Some engineers work across both domains, especially in small teams. It's possible, but you should hire for it explicitly rather than assume it.&lt;/p&gt;

&lt;p&gt;Kotlin Multiplatform (KMP) is a third option that sits between the two. KMP engineers share selected business logic, networking, and data layers across platforms while keeping platform-specific code where needed. A KMP role requires understanding Gradle, source sets, and native constraints, and it's usually a better fit for teams that want to share logic between an Android app and an iOS app rather than split work between mobile and server.&lt;/p&gt;

&lt;p&gt;The practical rule is simple: a full-stack Kotlin developer can be valuable, but you should confirm depth in each domain. An engineer who has shipped production Android apps and production backend services is rare. A mobile developer who has written one Ktor endpoint is not the same as a backend engineer.&lt;/p&gt;

&lt;h2&gt;
  
  
  Decision Checklist
&lt;/h2&gt;

&lt;p&gt;Use these questions to decide which specialist to hire. If most answers point to one column, that's your role.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fh6oxuizl9swdj5fzqf70.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fh6oxuizl9swdj5fzqf70.png" alt="A questionnaire table helping to determine whether a project requires an Android developer or a Backend developer based on project needs" width="594" height="336"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Writing the domain into the job description matters as much as the decision itself. A job post that says "Kotlin developer" without a domain attracts candidates who may not match your work. Name the domain, framework, and stack explicitly in the first paragraph of the posting.&lt;/p&gt;

&lt;h2&gt;
  
  
  Key Takeaways
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;An Android Kotlin developer builds mobile clients, while a backend Kotlin developer builds services and APIs. Both use Kotlin, but the frameworks and concerns differ.&lt;/li&gt;
&lt;li&gt;Kotlin is a language, not a platform. Treating Kotlin and Android as synonymous leads to mis-hires.&lt;/li&gt;
&lt;li&gt;Android hiring should prioritize Compose, ViewModel, StateFlow, lifecycle handling, and UI testing.&lt;/li&gt;
&lt;li&gt;Backend hiring should prioritize Spring Boot or Ktor, API design, persistence, security, observability, and deployment.&lt;/li&gt;
&lt;li&gt;If you need shared logic across platforms, evaluate Kotlin Multiplatform as a separate role rather than forcing one developer into every domain.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Frequently Asked Questions
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Is Kotlin only used for Android?&lt;/strong&gt;&lt;br&gt;
No. Kotlin runs on the JVM and supports backend development through frameworks such as Spring Boot, Ktor, and Quarkus. It's also used for Kotlin Multiplatform projects that share logic across platforms.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do backend Kotlin developers need Android experience?&lt;/strong&gt;&lt;br&gt;
Not usually. Backend roles need server-side skills such as API design, persistence, security, and deployment. Android experience is only relevant if the backend team also builds or maintains mobile clients.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Can a backend Kotlin developer build my Android app?&lt;/strong&gt;&lt;br&gt;
Only if they have proven mobile experience. Android development involves the SDK, lifecycles, and UI components, which a backend-only background doesn't cover. Ask for a production Android project, not only a Kotlin code sample.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What if my job description doesn't specify Android or backend?&lt;/strong&gt;&lt;br&gt;
Candidates will guess, and you'll receive a mix of profiles that may not fit. Specify the domain, framework, and stack in the first lines of the posting so applicants self-select correctly.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Should I hire one Kotlin developer or two?&lt;/strong&gt;&lt;br&gt;
It depends on the product. A small team building a mobile app with a simple API may find one full-stack engineer workable, but a product with a complex mobile client and a high-traffic backend usually benefits from specialists in each area.&lt;/p&gt;

&lt;h2&gt;
  
  
  Next Step
&lt;/h2&gt;

&lt;p&gt;If you're deciding between these roles for a specific project, &lt;a href="https://techhub.asia/how-to-hire-kotlin-developers/" rel="noopener noreferrer"&gt;the Kotlin hiring guide&lt;/a&gt; covers the full process, from defining the role to evaluating candidates. If you'd like help scoping the right profile, TechHub Asia can review your stack and domain requirements and recommend which specialist fits your project.&lt;/p&gt;

</description>
      <category>kotlin</category>
      <category>android</category>
      <category>backend</category>
      <category>discuss</category>
    </item>
    <item>
      <title>Remote Developer Salary Benchmarks 2026: Junior vs Senior Pay by Specialization</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Mon, 21 Sep 2026 08:35:22 +0000</pubDate>
      <link>https://dev.to/techhub_asia/remote-developer-salary-benchmarks-2026-junior-vs-senior-pay-by-specialization-e89</link>
      <guid>https://dev.to/techhub_asia/remote-developer-salary-benchmarks-2026-junior-vs-senior-pay-by-specialization-e89</guid>
      <description>&lt;p&gt;If you're setting compensation bands for a distributed team, generic salary surveys don't get you very far. Remote developer salary benchmarks in 2026 shift on three variables at once — seniority, specialization, and the region the developer is actually based in — and most public data only isolates one of those at a time.&lt;/p&gt;

&lt;p&gt;This article pulls those variables into a single reference: what junior, mid, and senior remote developers earn; how much AI/ML, security, and DevOps specialization adds on top; and how region shifts the baseline. Use it to sanity-check an offer, build a pay band, or push back on a recruiter's number.&lt;/p&gt;

&lt;h2&gt;
  
  
  How This Salary Data Was Compiled
&lt;/h2&gt;

&lt;p&gt;None of the figures below are original research. They're drawn from a handful of 2026 compensation studies — Nguyen (2026), Developers Matrix Research (2026), Robert Walters (2026), and PRS Research (2026) — each covering a different slice of the remote hiring market: seniority bands, regional averages, specialization premiums, and total employment cost.&lt;/p&gt;

&lt;p&gt;Where a figure is a direct data point from one of these sources, it's labeled as such. Where we've done simple math on top of a stated percentage (for example, applying a premium to a base salary), that's flagged as an illustrative calculation, not a separately sourced number.&lt;/p&gt;

&lt;h2&gt;
  
  
  Remote Developer Salary Benchmarks 2026, by Seniority Level
&lt;/h2&gt;

&lt;p&gt;Seniority is still the single biggest driver of remote developer pay. For US-based remote roles, a 2026 benchmark from Nguyen puts the bands at:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Junior Level&lt;/strong&gt;: For emerging talent, base compensation ranges from $78,000 to $130,000. This tier represents the foundational financial investment required to secure developing engineering capacity.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Mid Level&lt;/strong&gt;: As professionals achieve operational autonomy and technical proficiency, their market value naturally increases. Organizations should expect to allocate between $115,000 and $185,000 to attract and retain these critical, core contributors.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Senior Level&lt;/strong&gt;: Securing top tier technical leadership demands a premium investment. The compensation range for high impact senior professionals spans from $155,000 to $240,000, directly reflecting their capacity to drive and execute enterprise scale initiatives.&lt;/p&gt;

&lt;h2&gt;
  
  
  Junior vs Senior Remote Developer Salary — How Big Is the Gap?
&lt;/h2&gt;

&lt;p&gt;The junior vs senior remote developer salary gap is wide, and widest at the low end. Junior pay sits at roughly 50–84% of senior base pay, depending on stack and region. Mid-level pay is closer to senior — about 74% at the low end, rising to 94% at the high end (Nguyen, 2026).&lt;/p&gt;

&lt;p&gt;Two things worth noting for budget owners:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The range at each level is wide enough that "junior" and "senior" alone aren't a precise budget line. Stack, region, and remote-work experience move a candidate within their band as much as title does.&lt;/li&gt;
&lt;li&gt;Remote hiring can compress this gap faster than in-office hiring, since distributed teams tend to evaluate — and reprice — strong performers on output rather than tenure.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For high-cost US markets specifically, senior pay runs higher still: Developers Matrix Research (2026) puts the senior average around $205,000 in markets like San Francisco, with staff and principal roles extending well beyond that, up to $320,000+. That's a high-cost-market data point, not a remote-average one, but it's useful if you're benchmarking against Bay Area offers specifically.&lt;/p&gt;

&lt;h2&gt;
  
  
  Specialization Premiums: AI/ML, Security, DevOps, and Blockchain
&lt;/h2&gt;

&lt;p&gt;Specialization changes the number more than most budget owners expect. According to Robert Walters (2026), the premiums over a comparable generalist engineer are:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Artificial Intelligence and Machine Learning&lt;/strong&gt;: Engineers in this domain command the highest market premium, ranging from 25% to 45% above generalist rates. This reflects the intense global demand for expertise in model development and enterprise deployment.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cybersecurity&lt;/strong&gt;: Security engineers require a premium of 15% to 25%. This compensation tier is driven by the critical necessity of protecting enterprise infrastructure and mitigating advanced threat risks.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;DevOps and Site Reliability Engineering&lt;/strong&gt;: These specialists maintain a 5% to 15% premium. This steady increase reflects their essential function in automating deployment pipelines and ensuring continuous system uptime.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Blockchain&lt;/strong&gt;: The premium for blockchain developers remains highly variable. Base compensation typically offers a modest increase over standard full-stack roles, but total packages can scale significantly higher depending on the engineer's protocol expertise and the inclusion of token-based incentives.&lt;/p&gt;

&lt;p&gt;The AI engineer salary premium is the largest and most consistent of the group — a reflection of how thin the pool of production-experience ML and LLM engineers still is relative to demand. DevOps salary remote rates sit at the other end: real, but modest, since DevOps and SRE skills are more widely distributed across the existing engineering pool.&lt;/p&gt;

&lt;p&gt;To make this concrete, applying those percentages to a $155,000 senior US baseline (the low end of Nguyen's senior range) gives an illustrative picture of what specialization does to the number:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Generalist Senior&lt;/strong&gt;: The foundational compensation for a senior software engineer without a specialized focus is established at $155,000.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;DevOps and Site Reliability Engineering&lt;/strong&gt;: Professionals in these critical infrastructure roles typically command a market rate between $163,000 and $178,000.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Security&lt;/strong&gt;: Senior security engineers require a significant premium, with illustrative pay ranging from $178,000 to $194,000, reflecting the paramount importance of enterprise protection and risk mitigation.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Artificial Intelligence and Machine Learning&lt;/strong&gt;: This specialization commands the highest market premium. Senior AI and ML engineers expect compensation between $194,000 and $225,000, driven by the intense global demand for advanced model development and deployment capabilities.&lt;/p&gt;

&lt;p&gt;This is a calculation, not a separately sourced salary figure — treat it as a way to reason about the premium, not a number to quote a candidate directly.&lt;/p&gt;

&lt;p&gt;Blockchain doesn't have a clean percentage in the available data, largely because token compensation and protocol-specific expertise make total comp highly variable role to role. Budget it case by case rather than as a fixed multiplier.&lt;/p&gt;

&lt;h2&gt;
  
  
  Regional Adjustment Factors for Remote Salaries
&lt;/h2&gt;

&lt;p&gt;The same seniority and specialization bands shift substantially by region. For senior-level roles, Developers Matrix Research (2026) reports:&lt;/p&gt;

&lt;h3&gt;
  
  
  United States
&lt;/h3&gt;

&lt;p&gt;In high-cost US markets, senior developer compensation averages approximately $205,000. For staff and principal engineering roles, financial commitments scale considerably, frequently exceeding $320,000.&lt;/p&gt;

&lt;h3&gt;
  
  
  Eastern Europe
&lt;/h3&gt;

&lt;p&gt;Organizations deploying capital in Eastern Europe should anticipate senior engineering salaries ranging from $60,000 to $100,000.&lt;/p&gt;

&lt;h3&gt;
  
  
  Latin America
&lt;/h3&gt;

&lt;p&gt;The compensation framework in Latin America spans from $55,000 to $110,000. Executives must note that rates push toward the higher end of this spectrum for roles that are paid in USD or established under US-contracted agreements.&lt;/p&gt;

&lt;h3&gt;
  
  
  Asia
&lt;/h3&gt;

&lt;p&gt;Securing senior talent in Asia requires an investment of $42,000 to $85,000. This baseline variance is driven by specific country economics, individual technical specialization, and whether the operational focus targets local or export markets.&lt;/p&gt;

&lt;p&gt;A few patterns worth flagging for anyone setting bands across regions:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The Eastern Europe range has moved up meaningfully — Developers Matrix Research notes it's risen from a $40,000–$80,000 band in earlier years to $60,000–$100,000 in 2026.&lt;/li&gt;
&lt;li&gt;Latin America shows the widest spread within a single region, largely driven by whether the role is paid in USD and contracted directly by a US company.&lt;/li&gt;
&lt;li&gt;Asia has the widest range of the four regions overall, which makes a single "Asia" line item a weak proxy — country and specialization matter more here than in the other three regions.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How to Use These Benchmarks to Set Your Own Bands
&lt;/h2&gt;

&lt;p&gt;A workable process for turning this data into an actual offer:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Start with seniority. Place the candidate in a junior/mid/senior band based on scope of past work, not years of experience alone.&lt;/li&gt;
&lt;li&gt;Apply specialization second. If the role is AI/ML, security, or DevOps-heavy, layer the relevant premium on top of the seniority baseline rather than benchmarking specialization roles against a generic average.&lt;/li&gt;
&lt;li&gt;Adjust for region last. Regional pay should reflect where the developer is based and paid, not where your company is headquartered — conflating the two is the most common budgeting mistake we see.&lt;/li&gt;
&lt;li&gt;Re-check specialization premiums periodically. As more engineers gain production LLM and agentic-AI experience, the AI/ML premium is one of the figures most likely to move over the next few benchmark cycles.&lt;/li&gt;
&lt;li&gt;Factor in total cost, not just base salary. PRS Research (2026) estimates fully remote roles cost employers roughly $4,700–$8,500 per employee per year in direct remote-support costs, versus $15,400–$25,500 for fully in-office roles — a gap worth building into the budget conversation, not just the salary line.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;If you're building out the broader hiring process rather than just the compensation piece, our full breakdown of remote developer hiring costs covers sourcing, interviewing, and onboarding alongside the cost side.&lt;br&gt;
&lt;a href="https://techhub.asia/hire-remote-developers/" rel="noopener noreferrer"&gt;Link&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Key Takeaways
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Seniority, specialization, and region each move remote developer pay independently — budget for all three, not just one.&lt;/li&gt;
&lt;li&gt;Junior remote developer pay sits at roughly 50–84% of senior base pay; mid-level sits at 74–94%.&lt;/li&gt;
&lt;li&gt;AI/ML specialization carries the largest premium (25–45% over a generalist), followed by security (15–25%) and DevOps/SRE (5–15%).&lt;/li&gt;
&lt;li&gt;Regional senior-level pay ranges from roughly $42,000 (parts of Asia) to $320,000+ (US staff/principal roles) — a single "remote developer salary" number isn't meaningful without a region attached.&lt;/li&gt;
&lt;li&gt;Total cost of employment, not just base salary, is where fully remote roles show their biggest savings.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  FAQs
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;How much more should I pay a senior AI engineer vs. a senior backend engineer?&lt;/strong&gt;&lt;br&gt;
Based on Robert Walters (2026), expect an AI/ML engineer to command 25–45% more than a comparable generalist or backend engineer at the same seniority level. On a $155,000 senior baseline, that's roughly $194,000–$225,000.&lt;br&gt;
&lt;strong&gt;Do remote salaries differ by employee location or company location?&lt;/strong&gt;&lt;br&gt;
They should be set by employee location. The regional benchmarks above reflect where the developer is based and paid — a company headquartered in a high-cost market hiring into Eastern Europe or Southeast Asia should generally budget toward that developer's regional range, not the company's home-market range.&lt;br&gt;
&lt;strong&gt;Are specialization premiums shrinking as AI skills become more common?&lt;/strong&gt;&lt;br&gt;
The available 2026 data doesn't show that yet — the AI/ML premium (25–45%) is still the largest of the specializations tracked. It's plausible that premium narrows as more engineers gain production ML/LLM experience, but that's a trend to watch in future benchmark cycles rather than something reflected in current figures.&lt;br&gt;
&lt;strong&gt;What's the actual gap between junior and senior remote developer salary in 2026?&lt;/strong&gt;&lt;br&gt;
On the low end, junior pay is about half of senior pay. At the high end of each band, junior pay can reach roughly 84% of the senior figure. Mid-level pay is closer still, typically 74–94% of senior pay (Nguyen, 2026).&lt;br&gt;
&lt;strong&gt;How much can a company save by hiring fully remote vs. fully in-office?&lt;/strong&gt;&lt;br&gt;
PRS Research (2026) estimates a 20–30%-plus gap in annual per-employee cost: roughly $4,700–$8,500 for fully remote roles versus $15,400–$25,500 for fully in-office roles, driven by office-related overhead rather than base salary differences.&lt;br&gt;
&lt;strong&gt;Should I benchmark against US rates or local rates for a remote hire?&lt;/strong&gt;&lt;br&gt;
It depends on how the role is structured. USD-paid, US-contracted roles — common in Latin America, for example — tend to command higher pay than roles benchmarked purely against local market rates. Decide which model you're using before you set the number, since the two can differ by tens of thousands of dollars at the same seniority level.&lt;/p&gt;

&lt;p&gt;Setting a compensation band is only one piece of building a remote team. If sourcing, interviewing, and onboarding are the next question, TechHub Asia's complete guide to hiring remote developers walks through the full process end to end. &lt;a href="https://techhub.asia/hire-remote-developers/" rel="noopener noreferrer"&gt;Link&lt;/a&gt;&lt;/p&gt;

</description>
      <category>salary</category>
      <category>discuss</category>
      <category>developers</category>
      <category>hiring</category>
    </item>
    <item>
      <title>How to Detect AI Cheating in a Coding Interview (2026 Guide)</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Thu, 17 Sep 2026 07:57:12 +0000</pubDate>
      <link>https://dev.to/techhub_asia/how-to-detect-ai-cheating-in-a-coding-interview-2026-guide-4e0h</link>
      <guid>https://dev.to/techhub_asia/how-to-detect-ai-cheating-in-a-coding-interview-2026-guide-4e0h</guid>
      <description>&lt;p&gt;A candidate just gave a flawless answer to a hard system-design question, without a single pause to think. That used to be a good sign. In 2026, it's increasingly a reason to ask a harder follow-up before you decide anything.&lt;/p&gt;

&lt;p&gt;Learning how to detect AI cheating in a coding interview has become a genuine skill requirement for technical hiring managers, not a fringe concern. Remote and asynchronous formats — the same ones recommended for evaluating distributed candidates in the pillar guide on hiring remote developers — are also the formats most exposed to AI-assisted cheating, simply because no one can see the candidate's full environment. This guide covers what actually works: the behavioral signals worth trusting, how to structure take-home tests so they hold up, and the follow-up questioning techniques that expose a copied answer faster than any detection software.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why Remote and Async Interviews Are More Exposed to AI-Assisted Cheating
&lt;/h2&gt;

&lt;p&gt;AI-assisted interview cheating is the use of tools like ChatGPT, dedicated interview-overlay software, or a second device to generate answers for a candidate during an evaluation, without the interviewer's knowledge. It's grown sharply alongside remote hiring because a candidate controls their own screen, camera framing, and devices in a way that's impossible in an in-person room.&lt;/p&gt;

&lt;p&gt;The scale is no longer marginal. Fabric's analysis of over 50,000 candidates found AI-assisted cheating on assessments rose from about 15% in June 2025 to roughly 35% by December 2025. CodeSignal reported a similar trend on coding assessments specifically, climbing from about 16% in 2024 to around 35% in 2025. A Greenhouse survey found 65% of hiring managers say they've caught a candidate using AI deceptively, while separately, 22% of job seekers admit to using AI during a live interview — a gap suggesting a meaningful share of cheating simply isn't getting caught.&lt;/p&gt;

&lt;p&gt;Take-home tests are especially exposed: Fabric noted that a take-home assignment designed to take three hours can now be completed in minutes with a coding assistant, meaning the artifact you're grading no longer reliably measures the skill you're trying to assess.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to Detect AI Cheating in a Coding Interview: Behavioral Red Flags in Live Rounds
&lt;/h2&gt;

&lt;p&gt;Detecting AI-assisted interview cheating live comes down to noticing when a candidate's fluency and their ability to defend that fluency don't match. A few signals hold up better than others.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Inability to defend an answer under a natural follow-up. This is the single most reliable tell. A candidate who solved the problem themselves can usually go one layer deeper on demand. One who read an answer off a hidden screen often can't.&lt;/li&gt;
&lt;li&gt;Documentation-style phrasing. Answers that sound like they were lifted from technical docs or a textbook, rather than explained the way a person naturally talks through their own reasoning.&lt;/li&gt;
&lt;li&gt;A consistent short pause before answering, followed by an unusually complete, well-structured response — a pattern that shows up repeatedly in 2026 detection research, distinct from normal "thinking out loud" hesitation.&lt;/li&gt;
&lt;li&gt;A sharp mismatch between speed and depth. Code that appears essentially complete with no visible trial-and-error, or a hard problem solved in a fraction of the time it typically takes, are patterns coding platforms like HackerRank now score explicitly, alongside classic code-similarity checks.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Signals that are less reliable than most guides suggest:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Older advice like "watch for suspicious eye movement" was a real signal when ChatGPT was unfamiliar to candidates. By 2026, most people using overlay tools have practiced reading from a second screen positioned just below the camera specifically to avoid this tell — treat eye movement alone as weak evidence, not a verdict.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Structuring Take-Home Tests to Reduce Cheating Value
&lt;/h2&gt;

&lt;p&gt;The goal isn't to build a take-home test AI can't touch — that's no longer realistic. It's to structure the test so that using AI well is itself a meaningful signal, and using it poorly is obvious.&lt;/p&gt;

&lt;p&gt;A take-home format that holds up in 2026 tends to include four elements:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A tight scope — two focused hours, not an open-ended weekend project. A narrow scope makes copy-paste patterns and unrealistic completion times easier to notice.&lt;/li&gt;
&lt;li&gt;A rubric shared with the candidate up front, so you're grading decision-making and trade-offs, not guessing at intent from the artifact alone.&lt;/li&gt;
&lt;li&gt;An explicit, stated AI-use policy — allowed and disclosed, restricted to certain tools, or prohibited — rather than an unstated assumption candidates have to guess at.&lt;/li&gt;
&lt;li&gt;A mandatory live debrief, where the candidate walks an engineer through their own submission. This is the step that actually catches shallow understanding — skip it, and you're scoring an artifact you can't verify.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A few additional choices help against known patterns: randomized test cases prevent candidates from hardcoding answers to known inputs, and rotating challenges out once they're consistently solved too easily keeps a test useful as AI tools improve.&lt;/p&gt;

&lt;h2&gt;
  
  
  Follow-Up Questioning Techniques That Expose Shallow Understanding
&lt;/h2&gt;

&lt;p&gt;Questioning is more reliable than most detection software, because it tests understanding directly rather than trying to infer it from typing patterns.&lt;/p&gt;

&lt;p&gt;A few techniques consistently work well:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Ask for the reasoning before the code. Have the candidate describe their approach out loud before typing, rather than after — this reverses the sequence most cheating tools are built around, since there's nothing yet to read from an overlay if the explanation comes first.&lt;/li&gt;
&lt;li&gt;Ask them to explain one specific line, chosen by you, not by them. "Walk me through why you used a hash map here instead of sorting first" is harder to answer convincingly from shallow understanding than a general "walk me through your solution."&lt;/li&gt;
&lt;li&gt;Introduce a small change mid-interview. Ask the candidate to modify a constraint (a different input size, an added edge case) and adapt their existing solution live. Genuine understanding adapts; a memorized or fed answer often doesn't.&lt;/li&gt;
&lt;li&gt;Ask what they'd do differently with more time, or what they're least confident about. Candidates who solved the problem themselves usually have a specific, honest answer; a generic "I think it's solid" is a weaker sign.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Tools and Techniques Hiring Teams Use in 2026
&lt;/h2&gt;

&lt;p&gt;No single tool catches every cheating method, since live and asynchronous formats are exposed to different techniques. When securing the integrity of the technical hiring process, leadership must understand the evolving landscape of interview fraud. &lt;/p&gt;

&lt;h3&gt;
  
  
  Desktop Overlay Tools
&lt;/h3&gt;

&lt;p&gt;Applications such as Cluely and Interview Coder render AI generated answers directly on the candidate's screen. This mechanism creates an interface that remains invisible to standard screen sharing software. These tools are highly effective at evading detection during live video interviews. To mitigate this risk, interviewers must utilize rigorous follow up questioning and require candidates to explain their logical reasoning before executing any code.&lt;/p&gt;

&lt;h3&gt;
  
  
  Voice-Mode Assistants
&lt;/h3&gt;

&lt;p&gt;Candidates deploying this method use a hidden earpiece to communicate with tools like ChatGPT off camera, allowing them to repeat the generated answers to the interviewer. This tactic is most effective during live interviews, particularly within verbal system design rounds. Detection relies on identifying sudden shifts in verbal fluency and recognizing a candidate's inability to elaborate when pressed with deeper follow up inquiries.&lt;/p&gt;

&lt;h3&gt;
  
  
  Browser Extensions
&lt;/h3&gt;

&lt;p&gt;These extensions operate within a browser tab that frequently sits outside the visibility of standard proctoring software. They are predominantly effective at bypassing security measures during take home tests and on browser based coding platforms. Organizations can catch this behavior by deploying code similarity analyzers and behavioral pattern tracking tools, such as keystroke timing monitors.&lt;/p&gt;

&lt;h3&gt;
  
  
  General LLM Use on Take-Home Assignments
&lt;/h3&gt;

&lt;p&gt;In this scenario, a candidate pastes the assignment prompt directly into an artificial intelligence tool and submits the resulting output largely unmodified. This approach is highly effective for unsupervised take home tests. The most reliable countermeasure is instituting a mandatory live debrief that incorporates rubric based questioning focused specifically on the submitted code.&lt;/p&gt;

&lt;p&gt;Platforms like CoderPad and HackerRank now combine classic code-similarity checks with behavioral signals — keystroke timing, the presence or absence of normal debugging, and unusually fast time-to-solution ratios — which vendors report as meaningfully more accurate than similarity checks alone. These tools are genuinely useful for take-home and async formats, but neither can see an invisible overlay in a live round, since there's no anomalous typing pattern when a candidate is simply reading an answer aloud. Match the tool to the format, and don't assume take-home detection protects your live interviews.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to Do If You Suspect a Candidate Cheated
&lt;/h2&gt;

&lt;p&gt;A single red flag is a reason to ask another question, not to end the interview. Treat suspicion as a hypothesis to test in the moment:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Ask a direct, specific follow-up immediately, rather than waiting until after the interview to flag it internally — a follow-up in the moment is the clearest test you have.&lt;/li&gt;
&lt;li&gt;Note the specific pattern, not just a feeling. "Couldn't explain the hash map choice when asked directly" is useful signal for the hiring team; "seemed off" isn't.&lt;/li&gt;
&lt;li&gt;Avoid a false accusation based on a single weak signal, like eye movement alone or a slight pause — these produce real false positives, particularly for candidates who are simply nervous.&lt;/li&gt;
&lt;li&gt;Loop in a second interviewer for the next round if genuine doubt remains, rather than making a unilateral pass/fail call from one ambiguous session.&lt;/li&gt;
&lt;li&gt;Decide your AI-use policy before the interview, not during it. If your process allows disclosed AI use, a candidate using it isn't cheating — the issue is only undisclosed use presented as unaided work.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Key Takeaways
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;AI-assisted interview cheating has moved from a rare occurrence to a measurable share of remote hiring, with multiple 2026 analyses reporting adoption rates in the 30–35% range on coding assessments.&lt;/li&gt;
&lt;li&gt;The most reliable detection method isn't software — it's a candidate's inability to defend their own answer under a direct, specific follow-up question.&lt;/li&gt;
&lt;li&gt;"Watch for eye movement" is weaker evidence in 2026 than it used to be, since many candidates have practiced around it.&lt;/li&gt;
&lt;li&gt;A well-structured take-home test (tight scope, shared rubric, stated AI policy, mandatory live debrief) resists cheating better than trying to ban AI outright.&lt;/li&gt;
&lt;li&gt;Detection tools work differently for live versus asynchronous formats — match the tool to the format rather than assuming one covers both.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  FAQs
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Is it wrong to let candidates use AI tools during interviews?&lt;/strong&gt; Not inherently. A growing number of engineering teams treat AI fluency as a skill worth assessing rather than banning outright, testing how well a candidate prompts, evaluates, and debugs AI-assisted output. The problem isn't AI use — it's undisclosed use presented as unaided work.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Should I ban AI tools entirely or test AI-augmented workflow skills?&lt;/strong&gt; It depends on the role. Where AI-assisted development is part of the actual job, testing disclosed AI-augmented workflow — including how a candidate evaluates and corrects AI-generated code — is often a more realistic signal than a ban most candidates will quietly ignore. For roles assessing raw problem-solving fundamentals, a clearly stated no-AI policy with live proctoring fits better. Either way, state the policy explicitly.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What's a good follow-up question to expose a copied solution?&lt;/strong&gt; Ask the candidate to explain one specific line or decision you choose, not one they choose, and ask what they'd change if a constraint shifted. Genuine understanding adapts to a new constraint in real time; a copied or fed answer usually can't.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do I stop candidates from using AI in take-home tests?&lt;/strong&gt; You likely can't stop it outright, but you can reduce its value: keep the assignment tightly scoped, state your AI policy explicitly, and make a live debrief mandatory. A candidate who can't explain their own submission in detail fails the debrief regardless of how the code itself looks.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What are the signs a candidate used ChatGPT in a coding interview?&lt;/strong&gt; The most reliable signs are a mismatch between answer fluency and the candidate's ability to defend it under follow-up, documentation-style phrasing instead of natural explanation, and a hard problem solved unusually fast with no visible trial-and-error. Eye movement and long pauses are weaker, more easily coached-around signals.&lt;/p&gt;

&lt;p&gt;Interview integrity is one piece of a much larger process — the interview step in our remote hiring guide covers how to design the rest of a remote-friendly evaluation loop, from defining requirements through onboarding. &lt;br&gt;
&lt;a href="https://techhub.asia/hire-remote-developers/" rel="noopener noreferrer"&gt;Link&lt;/a&gt;&lt;br&gt;
If verifying every candidate's real skill level in-house isn't a realistic use of your team's time, that's exactly the gap a pre-vetted hiring pipeline is built to close before a candidate reaches your calendar.&lt;/p&gt;

</description>
      <category>coding</category>
      <category>discuss</category>
      <category>developer</category>
      <category>ai</category>
    </item>
    <item>
      <title>Stop Asking Salesforce Devs the Wrong Interview Questions</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Wed, 26 Aug 2026 07:32:18 +0000</pubDate>
      <link>https://dev.to/techhub_asia/stop-asking-salesforce-devs-the-wrong-interview-questions-h25</link>
      <guid>https://dev.to/techhub_asia/stop-asking-salesforce-devs-the-wrong-interview-questions-h25</guid>
      <description>&lt;p&gt;Every growing organization hits a wall where Salesforce stops being a plug-and-play CRM and becomes a custom enterprise application.&lt;br&gt;
When your org reaches the point where standard Flow, point-and-click UI, and basic validation rules can no longer handle your business logic, you need a developer. But scaling a Salesforce team often goes wrong during the technical screen. Certificates like PD1 and PD2 are great baselines, but they don't prove someone can architect a scalable solution for a multi-tenant environment.&lt;/p&gt;

&lt;p&gt;If you are a CTO, Tech Lead, or technical founder tasked with hiring Salesforce talent, here is how you should actually be screening candidates in 2026.&lt;/p&gt;
&lt;h2&gt;
  
  
  1. Test for Bulkification &amp;amp; Governor Limits (The Apex Trap)
&lt;/h2&gt;

&lt;p&gt;Salesforce operates in a multi-tenant environment with strict resource limits (Governor Limits). A developer accustomed to traditional server-side languages might write code that works perfectly for a single record but catastrophically fails during a bulk data load.&lt;/p&gt;

&lt;p&gt;During an interview, present a basic Apex Trigger scenario. If they write a SOQL query or DML statement inside a for loop, that's your signal to dig deeper.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight apex"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Red Flag: Never do this&lt;/span&gt;
&lt;span class="n"&gt;trigger&lt;/span&gt; &lt;span class="n"&gt;AccountTrigger&lt;/span&gt; &lt;span class="n"&gt;on&lt;/span&gt; &lt;span class="n"&gt;Account&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;before&lt;/span&gt; &lt;span class="k"&gt;insert&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Account&lt;/span&gt; &lt;span class="n"&gt;acc&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;Trigger&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="py"&gt;new&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="c1"&gt;// Query inside a loop will hit the 100 SOQL limit fast&lt;/span&gt;
        &lt;span class="n"&gt;List&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Contact&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;contacts&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="k"&gt;SELECT&lt;/span&gt; &lt;span class="n"&gt;Id&lt;/span&gt; &lt;span class="k"&gt;FROM&lt;/span&gt; &lt;span class="n"&gt;Contact&lt;/span&gt; &lt;span class="k"&gt;WHERE&lt;/span&gt; &lt;span class="n"&gt;AccountId&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="n"&gt;acc&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="py"&gt;Id&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Top-tier candidates will instantly talk about collecting IDs in a Set, querying outside the loop, and using Maps to tie records back together. It should look something like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight apex"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Bulk-safe: query once, outside the loop&lt;/span&gt;
&lt;span class="n"&gt;trigger&lt;/span&gt; &lt;span class="n"&gt;AccountTrigger&lt;/span&gt; &lt;span class="n"&gt;on&lt;/span&gt; &lt;span class="n"&gt;Account&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;before&lt;/span&gt; &lt;span class="k"&gt;insert&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;Set&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Id&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;accountIds&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;Set&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Id&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Account&lt;/span&gt; &lt;span class="n"&gt;acc&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;Trigger&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="py"&gt;new&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;accountIds&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;add&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;acc&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="py"&gt;Id&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="n"&gt;Map&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;List&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Contact&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;contactsByAccount&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;Map&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;List&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Contact&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Contact&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="k"&gt;SELECT&lt;/span&gt; &lt;span class="n"&gt;Id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;AccountId&lt;/span&gt; &lt;span class="k"&gt;FROM&lt;/span&gt; &lt;span class="n"&gt;Contact&lt;/span&gt; &lt;span class="k"&gt;WHERE&lt;/span&gt; &lt;span class="n"&gt;AccountId&lt;/span&gt; &lt;span class="n"&gt;IN&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="n"&gt;accountIds&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;contactsByAccount&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;containsKey&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="py"&gt;AccountId&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;contactsByAccount&lt;/span&gt;&lt;span class="o"&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;c&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="py"&gt;AccountId&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="n"&gt;List&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Contact&lt;/span&gt;&lt;span class="o"&gt;&amp;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;contactsByAccount&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="py"&gt;AccountId&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;add&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="c1"&gt;// Now work with the map — one query, no matter how many records are in the batch&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That's the difference between code that works in the sandbox and code that survives a real data load.&lt;/p&gt;

&lt;p&gt;What's the worst governor-limit bug you've caught in a code review? Curious what patterns show up most in practice.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Prioritize LWC Over Legacy Tech
&lt;/h2&gt;

&lt;p&gt;If your candidate's primary front-end experience is in Visualforce or Aura components, you are hiring for legacy tech debt.&lt;/p&gt;

&lt;p&gt;Modern Salesforce UI development runs on Lightning Web Components (LWC). You want developers who are deeply comfortable with standard web standards:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Native JavaScript (ES6+)&lt;/li&gt;
&lt;li&gt;Decorators (@api, @track, @wire)&lt;/li&gt;
&lt;li&gt;Understanding the DOM and shadow boundaries&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Ask them how they handle asynchronous data in LWC — imperative Apex calls versus relying on standard wire adapters. A candidate who reaches for @wire by default, and only drops to imperative Apex when they need to control when the call fires, understands the model:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Wire adapter: reactive, fires automatically when accountId changes&lt;/span&gt;
&lt;span class="p"&gt;@&lt;/span&gt;&lt;span class="nd"&gt;wire&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;getContacts&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="na"&gt;accountId&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;$accountId&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt; &lt;span class="p"&gt;})&lt;/span&gt;
&lt;span class="nx"&gt;contacts&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="c1"&gt;// Imperative: fires only when you call it — e.g. after a button click&lt;/span&gt;
&lt;span class="nf"&gt;handleRefresh&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nf"&gt;getContacts&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt; &lt;span class="na"&gt;accountId&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;accountId&lt;/span&gt; &lt;span class="p"&gt;})&lt;/span&gt;
        &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;then&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;contacts&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;result&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="k"&gt;catch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;error&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;this&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;error&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;error&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;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If a candidate can't articulate why you'd pick one over the other, that's worth probing further — not necessarily a dealbreaker, but a gap.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Screen for SFDX and CI/CD Fluency
&lt;/h2&gt;

&lt;p&gt;The days of deploying changes using standard Change Sets in the Salesforce UI are over.&lt;/p&gt;

&lt;p&gt;If a candidate is only comfortable working out of the Developer Console or the Setup UI, they will struggle to integrate into a modern engineering team. Your screen should verify their fluency in DevOps tooling:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Salesforce CLI (sf/sfdx): Can they authenticate orgs, retrieve/deploy metadata, and spin up scratch orgs?&lt;/li&gt;
&lt;li&gt;Version Control: Do they understand Git-based workflows and package-based development?&lt;/li&gt;
&lt;li&gt;Pipelines: Have they been exposed to automated deployment tools like GitHub Actions, Copado, or Gearset?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A quick way to test this without a full pipeline setup: ask them to walk through the commands they'd run to spin up a scratch org and push source to it.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;em&gt;Create a scratch org&lt;/em&gt;&lt;br&gt;
sf org create scratch --definition-file config/project-scratch-def.json --alias my-scratch-org&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Push source to it&lt;/em&gt;&lt;br&gt;
sf project deploy start --target-org my-scratch-org&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Run Apex tests&lt;/em&gt;&lt;br&gt;
sf apex run test --target-org my-scratch-org --result-format human&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If they can't get through this without hesitating, they've likely been working in a click-and-deploy world — which won't scale with your team.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Rest of the Equation: Market Rates and Team Structure
&lt;/h2&gt;

&lt;p&gt;Evaluating technical depth is only half the battle. Knowing how to structure a team (balancing senior architects with junior builders) and knowing what to pay them is the other half.&lt;/p&gt;

&lt;p&gt;If you are actively budgeting for a new hire or trying to decide between a freelancer, an agency, or an in-house developer, we've compiled the complete data for this year — 2026 salary benchmarks (from $95/hr freelancers to enterprise agency project costs), where to source pre-vetted talent, and our exact 30/60/90-day onboarding playbook for new Salesforce engineers.&lt;/p&gt;

&lt;p&gt;Link to the full breakdown: &lt;a href="https://techhub.asia/how-to-hire-salesforce-developers/" rel="noopener noreferrer"&gt;Link&lt;/a&gt;&lt;/p&gt;

</description>
      <category>salesforce</category>
      <category>hiring</category>
      <category>webdev</category>
      <category>discuss</category>
    </item>
    <item>
      <title>Stop Using Live Whiteboard Interviews to Hire Remote Developers</title>
      <dc:creator>TechHub Nguyen</dc:creator>
      <pubDate>Fri, 07 Aug 2026 05:02:34 +0000</pubDate>
      <link>https://dev.to/techhub_asia/stop-using-live-whiteboard-interviews-to-hire-remote-developers-1dgg</link>
      <guid>https://dev.to/techhub_asia/stop-using-live-whiteboard-interviews-to-hire-remote-developers-1dgg</guid>
      <description>&lt;p&gt;If you've been hired for a remote engineering role recently, you've probably run into this problem: the candidate who aced your technical interview turns out to be the one who quietly stalls your sprint two months later. Everyone on the team liked them. Their code review comments looked fine. And yet tickets kept sitting untouched for days, and nobody could quite explain why.&lt;/p&gt;

&lt;p&gt;That's not bad luck, and it's not a hiring mistake in the way most people think about hiring mistakes. It's a mismatch between what your interview process measures and what the job actually requires. Most technical interviews are still built around synchronous, in-office work: a candidate solves a problem live on a call, an engineering manager watches and asks follow-up questions, everyone reacts in real time. That format tests a real skill. It's just not the skill that determines whether someone succeeds on a distributed team.&lt;/p&gt;

&lt;p&gt;Remote work runs on a different capability almost entirely: asynchronous discipline. That's the ability to keep making progress when nobody is available to unblock you, and to communicate your work clearly enough that a teammate twelve time zones away can pick it up without a live conversation. A developer can be excellent at solving problems on the spot and still be weak at this. Interviews rarely separate the two, which is exactly why so many technically strong hires underperform once they're actually working remotely.&lt;/p&gt;

&lt;h2&gt;
  
  
  The two skills, in plain terms
&lt;/h2&gt;

&lt;p&gt;Synchronous technical skill is what you're testing when you put someone in front of a whiteboard or a shared coding environment and watch them think out loud. It tells you how someone performs under observation, with help nearby if they get stuck.&lt;/p&gt;

&lt;p&gt;Asynchronous operational skill is something else. It's what determines whether someone can still be productive eight hours into a blocker, with no manager online, no Slack response coming anytime soon, and a decision to make about what to do next. Almost no standard interview process measures this directly, even though it's the actual daily condition of most remote jobs.&lt;/p&gt;

&lt;h2&gt;
  
  
  When a live coding round still makes sense
&lt;/h2&gt;

&lt;p&gt;If the role genuinely involves real-time collaboration, pairing sessions, or fast incident response with a co-located team, testing raw problem-solving speed under observation is reasonable, because that's close to the real working condition.&lt;/p&gt;

&lt;p&gt;For most distributed roles, though, this format tells you almost nothing about how someone behaves when no one is watching, which is the situation they'll actually be in most of the time.&lt;/p&gt;

&lt;h2&gt;
  
  
  The better test: a specific take-home, not an open-ended one
&lt;/h2&gt;

&lt;p&gt;Give the candidate a broken repository and one clearly defined bug to fix. Set a reasonable deadline, and then don't hover. What you're actually evaluating isn't whether they fix the bug — most competent developers will. What you're evaluating is how they submit it.&lt;/p&gt;

&lt;p&gt;This is the part almost every hiring process skips, and it's the part that matters most. When you review the take-home, don't stop at whether the code works. Read the pull request the way a remote teammate would have to read it, with zero context and no ability to ask a quick clarifying question. Did they document their reproduction steps, or did they just submit a diff and assume you'd figure it out? Did they explain why they chose their specific approach, or leave you to reverse-engineer their reasoning? Would someone in a different time zone understand the fix well enough to build on it without a follow-up call?&lt;/p&gt;

&lt;p&gt;A developer who writes clean code but can't communicate technical context in writing will block your pipeline constantly. It usually takes months to notice, because the problem looks like a communication issue rather than a hiring issue.&lt;/p&gt;

&lt;h2&gt;
  
  
  The one interview question that predicts more than the rest of the interview combined
&lt;/h2&gt;

&lt;p&gt;Put the candidate in a specific scenario: they're working on a feature, they hit a blocker, and the only person who can unblock them is asleep for the next eight hours. What do they actually do?&lt;/p&gt;

&lt;p&gt;Most candidates describe some version of waiting, checking back later, or sending a message and moving on to something unrelated. The answer that actually predicts remote success looks different. It sounds like documenting the blocker with what's already been tried, pushing their current state so the work isn't lost, and immediately picking up a different ticket from the backlog rather than sitting idle.&lt;/p&gt;

&lt;p&gt;That one question filters for self-direction and output continuity faster than almost anything else you can put in a technical interview.&lt;/p&gt;

&lt;h2&gt;
  
  
  The decision in one question
&lt;/h2&gt;

&lt;p&gt;Will this person regularly need to keep working without anyone available to unblock them?&lt;/p&gt;

&lt;p&gt;If the honest answer is yes, and for most distributed roles it is, testing asynchronous skills directly through a take-home, a PR review, and a blocker-handling question matters as much as testing technical ability, maybe more. If the role is genuinely synchronous, a live technical round is still a reasonable choice. And if you're not sure which category the role falls into, it's worth assuming the async version, because most "occasionally remote" roles turn out to be async-heavy in practice once the team is actually distributed across time zones.&lt;/p&gt;

&lt;p&gt;None of this replaces technical evaluation. A developer still needs to write good code. But technical skill alone doesn't predict whether someone will thrive on a distributed team, and treating it as the whole evaluation is why so many companies keep hiring well on paper and struggling in practice.&lt;/p&gt;

&lt;h2&gt;
  
  
  For reference: our full hiring guide
&lt;/h2&gt;

&lt;p&gt;We put together a more complete breakdown of this, covering the full evaluation framework, current salary benchmarks for remote engineers by region and tech stack, and the onboarding steps that keep new hires from losing their first two weeks to access delays and permission requests. If you're actively rebuilding your remote hiring process, it's worth a read before your next round of interviews.&lt;/p&gt;

&lt;p&gt;Full guide here: &lt;a href="https://techhub.asia/hire-remote-developers/" rel="noopener noreferrer"&gt;Link&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Over to the DEV community
&lt;/h2&gt;

&lt;p&gt;If you've conducted or been through remote technical interviews yourself: what's one question or exercise that actually predicted how someone performed on the job, versus one that looked impressive in the interview but told you nothing useful?&lt;/p&gt;

&lt;p&gt;And for anyone who's hired the wrong person despite a strong technical round — what do you think the process failed to test for?&lt;/p&gt;

</description>
      <category>hiring</category>
      <category>discuss</category>
      <category>workplace</category>
      <category>remotedeveloper</category>
    </item>
  </channel>
</rss>
