What is the purpose of the util.promisify function in Node.js?

Q: What is the purpose of the util.promisify function in Node.js?

**Target Audience:** Engineers preparing for Node.js phone screens — assumes basic Promise and callback familiarity. **Difficulty:** Easy > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Both the success and rejection paths below were **actually executed** on Node v24.19.0, not assumed from the function's name. ## 1. Why This Even Matters — A Story First An old appliance with a two-prong plug still works perfectly — the appliance itself has nothing wrong with it. It simply speaks a different physical interface than a modern three-prong outlet. An adapter does not rebuild the appliance; it sits between the two, translating one plug shape into the other, once, at the point of connection. `util.promisify` is that adapter for a callback-style function meeting an `async/await`-shaped codebase. ## 2. The Core Idea 📌 **Interview term: `util.promisify(fn)`** takes a function following Node's **error-first callb

The problem

Question presented to candidate: "You are working with an old library that only exposes callback-style APIs (error-first callbacks), and the rest of your codebase uses async/await. What is the standard way to bridge that gap without rewriting the library?"

What a strong answer should cover:

util.promisify(fn) takes a function following Node's error-first callback convention — fn(...args, (err, result) => {...}) — and returns a new function that instead returns a Promise, resolving with result or rejecting with err.
📌 This is verifiably correct for both outcomes, not just the happy path: a promisified function whose original callback is invoked with a result resolves correctly; one whose callback is invoked with an Error produces a genuinely rejected Promise, catchable with .catch() or try/catch.
It requires the target function to follow the exact error-first, callback-last convention — a function with a different callback signature (callback not last, multiple non-error result arguments in a non-standard shape) will not promisify correctly without a custom wrapper.
Many of Node's own built-in APIs already ship a .promises variant (e.g. fs.promises) or accept util.promisify directly (util.promisify(fs.readFile)) — a good answer knows both paths exist and that the built-in .promises versions are generally preferred where available, since they are maintained directly rather than wrapped.
This directly enables using async/await with a legacy callback API without waiting for (or forking) that library to add native Promise support — the wrapping happens once, typically in a small compatibility module, not at every call site.
A precise answer distinguishes util.promisify (a general, one-function-at-a-time conversion utility) from util.callbackify (its inverse — wrapping an async function to expose an error-first callback API instead), which solves the opposite integration problem.

Clarifying questions expected:

"Does the callback-style function actually follow the standard error-first, callback-last convention?" — util.promisify assumes exactly that shape.
"Is there already a built-in .promises variant available for this specific API?" — often preferable to wrapping manually.

Code / implementation expected: Yes — demonstrating both the success path and a genuine rejection path from a promisified function is the concrete, convincing part of this answer.

utilities
promises
async

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for Node.js phone screens — assumes basic Promise and callback familiarity. Difficulty: Easy

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Both the success and rejection paths below were actually executed on Node v24.19.0, not assumed from the function's name.

1. Why This Even Matters — A Story First

An old appliance with a two-prong plug still works perfectly — the appliance itself has nothing wrong with it. It simply speaks a different physical interface than a modern three-prong outlet. An adapter does not rebuild the appliance; it sits between the two, translating one plug shape into the other, once, at the point of connection.

util.promisify is that adapter for a callback-style function meeting an async/await-shaped codebase.

2. The Core Idea

📌 **Inter

The solution is hidden so you can try first

6 min read · 9 sections

Read the code

JavaScriptutil.promisify verified for both the success path and a genuine rejection path

const util = require("util");

function legacyAdd(a, b, cb) { setTimeout(() => cb(null, a + b), 10); }
const addAsync = util.promisify(legacyAdd);
addAsync(2, 3).then((r) => console.log("promisified result:", r));
// promisified result: 5

function legacyFail(cb) { setTimeout(() => cb(new Error("legacy failure")), 10); }
util.promisify(legacyFail)().catch((e) => console.log("promisified rejection:", e.message));
// promisified rejection: legacy failure

// A method needing "this" binding before promisifying:
// const readAsync = util.promisify(client.legacyRead.bind(client));

Discussion

Other approaches, follow-ups and how it went in real interviews.

Sign in to join the discussion.

No comments yet. Share how you would answer it.

The solution is hidden so you can try first

Keep your momentum going.