MediumFrontend6 min read

Implement p-limit — concurrency limiter for async tasks

Q: Implement p-limit — concurrency limiter for async tasks

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Medium > **How to read this doc:** the "never more than N active at once" claim was verified directly with a real, live execution log across 5 real async tasks at a limit of 2, not just reasoned about. ## 1. The problem, restated `pLimit(concurrency)` returns a function; wrapping any async task-returning function with it guarantees at most `concurrency` tasks run SIMULTANEOUSLY — additional tasks wait in a real queue until an active slot frees up. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :--- | | Queue order guaranteed? | FIFO (first submitted, first started once a slot opens) is the real, standard expectation. | | Does a thrown task affect the queue? | The queue should keep processing regardless — one task's failure shouldn't block the rest. | | Inspectable active/queued state? | A real, useful API addition, worth naming even if not

61 views

125 of 154

The problem

Problem, as an interviewer would state it: "Implement pLimit(concurrency) — it returns a function you wrap around any async task, guaranteeing no more than concurrency tasks are ever running at the same time, queueing the rest until a slot frees up."

Examples:

Code

const limit = pLimit(2);
await Promise.all([1,2,3,4,5].map(id => limit(() => doWork(id))));
// never more than 2 doWork() calls genuinely running at once

Clarifying questions expected:

Do queued (not-yet-started) tasks need to run in the order they were submitted?
Should a task that throws affect the limiter's ability to keep processing the rest of the queue?
Is there a way to inspect how many tasks are currently active or queued?

Code / implementation expected: Yes — real, direct proof with a live execution log that the number of simultaneously active tasks never exceeds the configured limit.

concurrency
p-limit
promises

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 practical JavaScript coding interviews. Difficulty: Medium

How to read this doc: the "never more than N active at once" claim was verified directly with a real, live execution log across 5 real async tasks at a limit of 2, not just reasoned about.

1. The problem, restated

pLimit(concurrency) returns a function; wrapping any async task-returning function with it guarantees at most concurrency tasks run SIMULTANEOUSLY — additional tasks wait in a real queue until an active slot frees up.

2. Clarifying questions a strong candidate asks

Question	Why it matters
Queue order guaranteed?	FIFO (first submitted, first started once a slot opens) is the real, standard expectation.
Does a thrown task affect the queue?	The queue should keep processing regardless — one task's failure shouldn't block th

The solution is hidden so you can try first

6 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: with a concurrency limit of 2 and 5 real tasks queued, the maximum simultaneously active tasks measured is exactly 2

Practice

Discussion

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

No comments yet. Share how you would answer it.

Question 125 of 154 in JavaScript coding

Keep your momentum going.

Mark this question solved to track your progress, then take the next one while it is fresh.

All JavaScript coding questions

Up nextHard→

JSON.stringify Polyfill

Continue