What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Yes—adding await to a synchronous function call can add measurable overhead when repeated in a tight loop. In a benchmark published by Panth Patel, one million direct calls to an empty synchronous function took 2 ms in Node.js, while awaiting each call took 51 ms. Those are the author’s results for one benchmark, not a universal per-call cost or a promise about every Node.js version.
What the 2 ms versus 51 ms benchmark measured
Patel’s article, published October 1, 2026, says the measurements were made in May 2025. It compares five patterns: direct calls to a synchronous function; awaiting a synchronous function; calling an async function without awaiting it; awaiting an async function; and collecting async calls before awaiting them with Promise.all. The cases were timed sequentially with Date.now(). Read Patel’s benchmark and code.
As an Amazon Associate I earn from qualifying purchases.
| Runtime | Direct sync | Sync with await |
Async, no await |
Async with await |
Async calls with Promise.all |
|---|---|---|---|---|---|
| Node.js | 2 ms | 51 ms | 7 ms | 46 ms | 171 ms |
| Chrome | 3 ms | 1,500 ms | 33 ms | 1,559 ms | not reported in this first-run table (Patel) |
| Deno | 1 ms | 49 ms | 7 ms | 42 ms | 183 ms |
| Bun | 2 ms | 73 ms | 19 ms | 74 ms | 130 ms |
All values in the table are timings reported by Patel for one million calls in his benchmark. They are not independently reproduced measurements. In a second run, he gave the functions a cnt++ body and reset the counter after each case. For Node.js, the reported figures were 10 ms for direct calls and 50 ms for awaited calls. The added function work did not erase the pattern in that run, but it remains the same author’s benchmark.
Why awaiting a plain value still has a cost
The synchronous function does not become asynchronous merely because its caller writes await. The function body runs as ordinary synchronous code when called. The extra work is associated with the async function that reaches await: the value is resolved as an awaitable result, the async execution suspends, and its continuation resumes through promise-job processing. The ECMAScript specification describes the Await operation and the job model that governs this behavior. See the ECMAScript 2027 Language Specification.
#1 Best Overall
That distinction matters in a loop. With await syncFunction() on every iteration, each iteration incurs async suspension and continuation work even though the call itself returns a plain value immediately. In Patel’s demonstration, the synchronous function body and Promise-constructor work happen before the current synchronous sequence completes; the .then callback and code after await run later. It is therefore misleading to say that the synchronous function body itself is deferred or that all “async work” simply goes to the event loop.
When removing await is—and is not—appropriate
If a function is synchronous and its returned value is immediately available, an unnecessary await in a measured hot loop may add overhead without making the function’s work asynchronous. Removing it can be worth considering when profiling identifies that loop as a bottleneck.
Rank #2
Do not remove await just to chase these benchmark numbers if the expression represents real asynchronous work, or if the surrounding code depends on waiting for its result, preserving order, or handling its rejection through the async control flow. Patel’s test measures simple repeated calls; it does not test application-level correctness or the effects of changing awaits in a production program.
Free tools Windows power users keep installed
One-click scans. No signup required.
How far to generalize the timing
The 2 ms and 51 ms figures are Patel’s reported measurements, not a stable cost-per-call formula. The article does not identify the exact Node.js, Chrome, Deno, or Bun versions, hardware, operating system, warm-up procedure, or number of repeated trials. Its use of Date.now() and sequential cases also limits what can be concluded about runtime performance more broadly. The results show that this benchmark’s awaited-call pattern took longer; they do not establish a universal ranking of runtimes or predict a particular application’s slowdown.
Rank #3
The scale of the reported difference also varies by runtime in Patel’s first-run results: for example, Chrome is reported at 3 ms for direct synchronous calls and 1,500 ms for awaited synchronous calls, while the Node.js figures are 2 ms and 51 ms. These cross-runtime numbers should be read only as outcomes of the author’s specified test, not as a general comparison of browser and server performance.
Quick Recap
Rank #4
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
