Node CPU Work, Worker Pools, and Event Loop Delay

Working case

A permit scoring endpoint receives a polygon with 47,000 points. One client requests a score while health checks and ordinary page requests are arriving. The handler computes the geometry synchronously and event loop delay jumps past the service budget. Starting one new worker for every score avoids blocking the main loop but creates hundreds of workers under burst load, trading latency for memory collapse. A small reused worker pool with a bounded queue admits a limited number of jobs and returns a busy response when full. The caller can cancel a queued job; a running computation needs cooperative interruption or termination with a clear cost.

Implementation boundary

function admitScoreTask({ points, queuedTasks, queueLimit }) {
  if (!Array.isArray(points) || points.length > 4700) return "invalid_input";
  if (queuedTasks >= queueLimit) return "busy";
  return "admitted";
}

console.log(admitScoreTask({ points: Array(47).fill(0), queuedTasks: 2, queueLimit: 3 }));

Measure the expensive section before moving it. Keep cheap validation on the request thread so a malformed input never occupies a worker. Pass a compact task payload and stable task ID to a fixed pool; copy or transfer large buffers deliberately instead of assuming shared access. Reserve concurrency based on available CPU and other workloads, not number of HTTP sockets. A canceled browser request should remove a queued job and release its slot; a running job may finish for audit or stop at checkpoints according to the business contract. A worker crash must reject its current task and be replaced under a controlled restart budget. Never accept arbitrary code or module names from the client as a worker task.

Cost and boundaries

For N input items the scoring computation may be O(N log N) or worse, depending on geometry rules; offloading does not reduce that algorithmic cost. It adds O(B) serialization or transfer preparation for B input bytes, plus a bounded queue of at most Q tasks and W worker heaps. Throughput eventually reaches the CPU limit; a larger pool can increase contention rather than useful work. Track event loop delay, worker utilization, queue wait, task duration, rejection count, result size, and crash replacement. Use a benchmark that includes mixed cheap requests, since an isolated worker benchmark misses the purpose of protecting request latency.

Failure trace

Run one expensive score beside a stream of tiny health requests and compare p95 event loop delay before and after offloading. Flood the endpoint with more jobs than the queue limit; excess calls must fail quickly and must not start more workers. Close one client while its task is queued and verify its slot is removed. Crash one worker during a task and ensure the task fails with a specific state rather than hanging forever. Feed an oversized polygon and make the cheap request boundary reject it before serialization. Measure CPU and resident memory as worker count rises, then choose a pool size from the actual machine budget.

Verification

Cheap requests stay responsive during admitted scoring work.
Worker and queue counts remain within configured limits.
Cancel and crash paths release task ownership.

Practice drill

Create a scoring task for permit 447 with 4,700 points and a result that includes the input revision. Compare a synchronous handler, one-worker-per-request handler, and a three-worker bounded pool while twenty small requests arrive. Record p95 event loop delay, queue age, and memory. Reject an input above a point cap, cancel a queued task, and simulate a worker crash. Ensure a stale result for revision 6 cannot overwrite revision 7. Write down the rule for retrying a score whose worker died after the computation completed but before its result was observed.

Decision note

Bound CPU admission before parallelizing; workers protect responsiveness but do not create capacity from nothing.

Common Mistakes

Assuming await makes a CPU loop yield to other requests.
Creating a new worker for every request with no queue bound.
Reporting only worker task time while request queue wait grows.

Apply and check

Build Project: Native Node Permit Gateway and review Web Development: Native Node Runtime Contracts.