Workers everywhere: which "worker" do you mean?

HOW IT FITS TOGETHER

KEY TERMS

Dedicated Web Worker

new Worker(url, { type: "module" }) starts a thread owned by one document. It has fetch, timers, IndexedDB and WebSocket but no DOM, window or localStorage. Data crosses by postMessage (structured clone or transfer); the main thread stays responsive while it computes.

SharedWorker

One instance per origin + script URL + name, reached from each tab through a MessagePort delivered in the connect event. Useful for deduplicating a socket or cache across tabs. MDN marks it Baseline 2026: Chrome on Android had it disabled for years and re-enabled it in Chrome 148. Ports give no close signal, so tabs must say goodbye themselves.

Service Worker

An event-driven proxy registered per origin and scope. It intercepts navigations and subresource requests in scope (fetch event), receives push and sync events with no tab open, and is terminated when idle. Its lifecycle (install, waiting, activate) guarantees only one version controls pages at a time, which is why deploys can appear stuck.

Worklets

Lightweight, purpose-specific scripts the browser calls from its own pipeline: AudioWorklet calls process() on the audio render thread once per render quantum (currently 128 frames); the CSS Paint API (paint worklets) is still experimental and not Baseline. They cannot be used for general computation and allow only static imports.

Threads vs processes on the server

worker_threads gives a Node process more JavaScript threads, each with its own isolate and event loop, sharing memory only through SharedArrayBuffer. cluster or PM2 forks whole processes that share a listening port but no memory. Node's docs: threads help CPU-intensive work, not I/O.

Job workers

BullMQ (Redis), Sidekiq (Ruby, Redis), Celery (Python, a broker) and Temporal workers (which poll task queues and run durable workflow code) are long-running processes that pull work from a durable store. Delivery is at least once, so handlers must be idempotent; the queue gives retries, backoff and visibility the request path does not.

Edge Workers

Cloudflare Workers run your fetch handler in V8 isolates inside an existing runtime, so there is no per-script process to cold start. Each isolate gets up to 128 MB; CPU time is limited per request (10 ms on Free, 30 s default on Paid). Isolates may be evicted at any time, so globals are a cache at best.

IN YOUR STACK

// main.js: promise wrapper with request ids
const worker = new Worker(new URL("./parse.worker.js", import.meta.url), { type: "module" });
const pending = new Map();
let nextId = 0;

worker.onmessage = ({ data }) => {
  pending.get(data.id)?.(data.rows);
  pending.delete(data.id);
};
worker.onerror = (event) => console.error("worker failed:", event.message);

export function parseCsvInWorker(csvText) {
  const id = nextId++;
  return new Promise((resolve) => {
    pending.set(id, resolve);
    worker.postMessage({ id, csvText }); // structured clone: the string is copied
  });
}

// parse.worker.js: no DOM here, just compute and post back
self.onmessage = ({ data }) => {
  const rows = data.csvText.split("\n").map((line) => line.split(","));
  self.postMessage({ id: data.id, rows });
};

// sw.js   (page: navigator.serviceWorker.register("/sw.js"))
const CACHE = "static-v3";
const PRECACHE = ["/", "/app.js", "/styles.css", "/offline.html"];
const dropOld = (keys) => Promise.all(keys.filter((key) => key !== CACHE).map((key) => caches.delete(key)));
self.addEventListener("install", (event) => event.waitUntil(caches.open(CACHE).then((c) => c.addAll(PRECACHE))));
self.addEventListener("activate", (event) => event.waitUntil(caches.keys().then(dropOld)));
self.addEventListener("fetch", (event) => {
  const { request } = event;
  if (request.method !== "GET" || new URL(request.url).origin !== location.origin) return;
  event.respondWith((async () => {
    const cached = await caches.match(request);
    if (cached) return cached;
    try {
      const response = await fetch(request);
      const copy = response.clone(); // clone now, before the page consumes the body
      if (response.ok) event.waitUntil(caches.open(CACHE).then((c) => c.put(request, copy)));
      return response;
    } catch {
      return (request.mode === "navigate" && (await caches.match("/offline.html"))) || Response.error();
    }
  })());
});

// tab.js: runs in every open tab
const hub = new SharedWorker(new URL("./hub.js", import.meta.url), { type: "module", name: "prices" });
hub.port.onmessage = ({ data }) => { document.querySelector("#price").textContent = data.price; };
hub.port.postMessage({ type: "subscribe" });
addEventListener("pagehide", () => hub.port.postMessage({ type: "bye" }));

// hub.js: one instance per origin + URL + name, shared by all tabs
const ports = new Set();
let socket = null;

self.onconnect = (event) => {
  const port = event.ports[0];
  port.onmessage = ({ data }) => {
    if (data.type === "subscribe") { ports.add(port); openSocketOnce(); }
    if (data.type === "bye") ports.delete(port);
  };
};

function openSocketOnce() {
  socket ??= new WebSocket("wss://api.example.com/prices");
  socket.onmessage = (event) => {
    for (const port of ports) port.postMessage(JSON.parse(event.data));
  };
}

import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads";
import { createHash } from "node:crypto";

if (isMainThread) {
  const hashInWorker = (input) => new Promise((resolve, reject) => {
    const worker = new Worker(new URL(import.meta.url), { workerData: input });
    worker.once("message", resolve);
    worker.once("error", reject);
    worker.once("exit", (code) => { if (code !== 0) reject(new Error(`worker exited with ${code}`)); });
  });
  // The event loop keeps serving requests while this runs on another core.
  console.log(await hashInWorker("seed"));
} else {
  let digest = workerData;
  for (let i = 0; i < 1_000_000; i++) digest = createHash("sha256").update(digest).digest("hex");
  parentPort.postMessage(digest);
}

import { Queue, Worker, type Job } from "bullmq";

const connection = { host: "127.0.0.1", port: 6379, maxRetriesPerRequest: null };

// Producer, in the API process: enqueue and return immediately.
export const emails = new Queue("emails", { connection });
export const enqueueWelcome = (userId: string) => emails.add("welcome", { userId }, {
  jobId: `welcome-${userId}`, // ignored while a job with this id still exists
  attempts: 5,
  backoff: { type: "exponential", delay: 1_000 },
  removeOnComplete: 1_000,
});

// Consumer, in a separate worker process or container.
const worker = new Worker("emails", async (job: Job<{ userId: string }>) => {
  await sendWelcomeEmail(job.data.userId); // may run twice: make it idempotent
}, { connection, concurrency: 10 });

worker.on("failed", (job, err) => console.error("job failed", job?.id, err.message));
worker.on("error", (err) => console.error("worker error", err));
process.on("SIGTERM", async () => { await worker.close(); process.exit(0); });

async function sendWelcomeEmail(userId: string) {
  console.log("send email to", userId); // pass an idempotency key to the provider
}

interface Env {
  PAGES: KVNamespace; // binding declared in wrangler config
  ORIGIN: string;     // e.g. "https://origin.example.com"
}

export default {
  async fetch(request, env, ctx): Promise<Response> {
    const url = new URL(request.url);
    if (request.method !== "GET") return fetch(new URL(url.pathname + url.search, env.ORIGIN), request);

    const key = `page:${url.pathname}`;
    const cached = await env.PAGES.get(key);
    if (cached !== null) return new Response(cached, { headers: { "content-type": "text/html", "x-cache": "hit" } });

    const upstream = await fetch(new URL(url.pathname, env.ORIGIN));
    if (!upstream.ok) return upstream;
    const html = await upstream.text();
    ctx.waitUntil(env.PAGES.put(key, html, { expirationTtl: 300 })); // runs after the response
    return new Response(html, { headers: { "content-type": "text/html", "x-cache": "miss" } });
  },
} satisfies ExportedHandler<Env>;

WHEN TO REACH FOR WHAT

WHERE IT BITES

• Deploying a new service worker and wondering why users still run the old app: the new version is waiting until every old tab closes. Prompt for reload and call skipWaiting deliberately rather than by default.
• Cache-first on HTML or API responses. The page is pinned to whatever was cached; reserve cache-first for hashed static assets.
• Posting huge objects to a worker on every frame. Structured clone runs on the sending thread too; transfer buffers or keep the data in the worker.
• Running CPU-heavy code in a BullMQ processor in-process: the lock is not renewed, the job stalls and runs twice. Use sandboxed processors or offload to threads.
• Treating an edge isolate's globals or a service worker's globals as durable state. Both are discarded without warning.
• Spawning a new worker_thread per request. Startup cost and memory dominate; use a bounded pool.

WHEN IT BREAKS IN PRODUCTION

• Offline edits conflict or vanish on reconnect
• The UI shows old data after a save
• One bad message blocks or floods the queue
• A brief blip turns into a long outage

SOURCES

• web.dev: The service worker lifecycle (opens in new tab)Checked 2026-10-11
• MDN: Using Service Workers (opens in new tab)Checked 2026-10-11
• MDN: SharedWorker (opens in new tab)Checked 2026-10-11
• Chrome 148 release notes (SharedWorker on Android) (opens in new tab)Checked 2026-10-11
• Node.js: Worker threads (opens in new tab)Checked 2026-10-11
• Cloudflare: How Workers works (opens in new tab)Checked 2026-10-11