Async batch processing in Rest API - Step-by-Step Execution

Concept Flow - Async batch processing

Receive batch request

↓

Split batch into tasks

↓

Start async processing of tasks

↓

Tasks run in parallel

↓

Collect task results

↓

Send combined response

The server receives a batch request, splits it into tasks, processes them asynchronously in parallel, collects results, and sends back a combined response.

Execution Sample

Rest API

POST /batch
Receive batch tasks
Start async tasks
Wait for all to finish
Return combined results

This code handles a batch request by processing tasks asynchronously and returning all results together.

Execution Table

Step	Action	Task ID	Status	Result	Notes
1	Receive batch request	-	Received	-	Batch with 3 tasks received
2	Split batch	-	Split	-	Tasks 1, 2, 3 identified
3	Start async task	1	Running	-	Task 1 started
4	Start async task	2	Running	-	Task 2 started
5	Start async task	3	Running	-	Task 3 started
6	Task 1 completes	1	Completed	Result A	Task 1 finished successfully
7	Task 2 completes	2	Completed	Result B	Task 2 finished successfully
8	Task 3 completes	3	Completed	Result C	Task 3 finished successfully
9	Collect results	-	Collected	Results A,B,C	All task results gathered
10	Send response	-	Sent	Results A,B,C	Combined results sent to client
11	Exit	-	-	-	All tasks done, response sent

💡 All async tasks completed and combined response sent to client

Variable Tracker

Variable	Start	After Step 2	After Step 5	After Step 8	Final
batch_tasks	[]	[1,2,3]	[1:running,2:running,3:running]	[1:done,2:done,3:done]	[1:done,2:done,3:done]
results	{}	{}	{}	{1:'Result A',2:'Result B',3:'Result C'}	{1:'Result A',2:'Result B',3:'Result C'}
response_sent	false	false	false	false	true

Key Moments - 3 Insights

Why do tasks run in parallel instead of one after another?

Because the server starts all tasks asynchronously at step 3-5, they run at the same time, speeding up total processing (see execution_table rows 3-5).

How does the server know when all tasks are done?

It waits until all tasks report completion (rows 6-8), then collects results at step 9 before sending the response.

What happens if one task takes longer than others?

The server waits for all tasks to finish before responding, so slower tasks delay the combined response (see variable_tracker showing all tasks done only at final).

Visual Quiz - 3 Questions

Look at the execution table, at which step does the server start processing task 2?

A Step 2

B Step 6

C Step 4

D Step 9

💡 Hint

Check the 'Action' and 'Task ID' columns in execution_table rows 3-5.

According to variable_tracker, what is the status of batch_tasks after step 5?

A [1:done,2:done,3:done]

B [1:running,2:running,3:running]

C [1:waiting,2:waiting,3:waiting]

D []

💡 Hint

Look at the 'batch_tasks' row under 'After Step 5' in variable_tracker.

If task 3 never completes, what step would the server never reach?

A Step 9

B Step 6

C Step 8

D Step 2

💡 Hint

See execution_table rows 6-9 for when results are collected after all tasks complete.

Concept Snapshot

Async batch processing:
- Receive batch request with multiple tasks
- Start all tasks asynchronously in parallel
- Wait for all tasks to complete
- Collect all results
- Send combined response
Key: parallel task execution speeds up processing

Full Transcript

Async batch processing means the server gets a batch of tasks and runs them all at the same time without waiting for each to finish before starting the next. The flow starts by receiving the batch, splitting it into individual tasks, and then starting each task asynchronously. Each task runs independently and finishes at its own time. The server waits until all tasks are done, collects their results, and sends back one combined response. This method is faster than running tasks one by one because it uses parallel processing. The execution table shows each step from receiving the batch to sending the response. The variable tracker shows how the list of tasks and results change over time. Key points include understanding parallel execution, waiting for all tasks to finish, and combining results before responding.

Practice

1. What is the main benefit of using async batch processing in REST APIs?

easy

A. It allows sending multiple requests at once to save time.

B. It makes each request slower but more secure.

C. It processes requests one by one to avoid errors.

D. It disables parallel processing to reduce server load.

Solution

1. Step 1: Understand async batch processing purpose

   Async batch processing sends many requests together instead of one at a time.

2. Step 2: Identify the benefit

   Sending requests together saves time and improves efficiency.

3. Final Answer:

   It allows sending multiple requests at once to save time. -> Option A

4. Quick Check:

   Async batch processing = multiple requests at once [OK]

Hint: Async batch sends many requests together to save time [OK]

Common Mistakes:

• Thinking async batch slows down requests
• Believing requests are processed one by one
• Confusing async batch with disabling parallelism

2. Which of the following is the correct way to start an async batch request in JavaScript using fetch?

easy

A. fetch('/batch', { method: 'GET', body: requests })

B. fetch('/batch', 'POST', requests)

C. fetch('/batch', { method: 'POST', body: JSON.stringify(requests) })

D. fetch('/batch', { method: 'POST', body: requests })

Solution

1. Step 1: Check fetch syntax for POST with JSON body

   fetch requires method and body as JSON string for POST requests.

2. Step 2: Identify correct option

   fetch('/batch', { method: 'POST', body: JSON.stringify(requests) }) uses method 'POST' and JSON.stringify to convert requests to string.

3. Final Answer:

   fetch('/batch', { method: 'POST', body: JSON.stringify(requests) }) -> Option C

4. Quick Check:

   fetch POST with JSON body = fetch('/batch', { method: 'POST', body: JSON.stringify(requests) }) [OK]

Hint: Use JSON.stringify for POST body in fetch [OK]

Common Mistakes:

• Passing body without JSON.stringify
• Using GET method with body
• Wrong fetch parameter order

3. Given this async batch code snippet, what will be the output?

const batchRequests = [
  fetch('/api/data1'),
  fetch('/api/data2'),
  fetch('/api/data3')
];

Promise.all(batchRequests)
  .then(responses => responses.map(r => r.status))
  .then(statuses => console.log(statuses));

medium

A. [Promise, Promise, Promise]

B. [200, 200, 200]

C. [undefined, undefined, undefined]

D. Error: Cannot read property 'status' of undefined

Solution

1. Step 1: Understand Promise.all with fetch

   Promise.all waits for all fetch requests to complete and returns an array of responses.

2. Step 2: Map responses to their status codes

   Each response has a status property, usually 200 if successful.

3. Final Answer:

   [200, 200, 200] -> Option B

4. Quick Check:

   Promise.all fetch statuses = [200, 200, 200] [OK]

Hint: Promise.all returns array of resolved values [OK]

Common Mistakes:

• Expecting promises instead of resolved responses
• Trying to access status before Promise.all resolves
• Confusing map on promises vs responses

4. Identify the error in this async batch processing code snippet:

async function batchFetch(urls) {
  const results = [];
  urls.forEach(async url => {
    const res = await fetch(url);
    results.push(await res.json());
  });
  return results;
}

medium

A. Using forEach with async does not wait for all fetches to finish.

B. Missing JSON.stringify on fetch body.

C. results array is declared inside the loop.

D. fetch should not be awaited inside async function.

Solution

1. Step 1: Analyze async inside forEach

   forEach does not wait for async callbacks, so results may be empty on return.

2. Step 2: Identify correct fix

   Use for...of loop with await or Promise.all to wait for all fetches.

3. Final Answer:

   Using forEach with async does not wait for all fetches to finish. -> Option A

4. Quick Check:

   forEach async does not await = Using forEach with async does not wait for all fetches to finish. [OK]

Hint: Avoid async inside forEach; use for...of or Promise.all [OK]

Common Mistakes:

• Assuming forEach waits for async callbacks
• Not returning or awaiting promises properly
• Misplacing results array declaration

5. You want to send 100 API requests in batches of 10 asynchronously to avoid overloading the server. Which approach correctly implements this in JavaScript?

hard

A. Send requests one by one using a for loop with await inside.

B. Send all 100 requests at once with Promise.all without batching.

C. Use a forEach loop with async fetch calls without awaiting.

D. Split URLs into chunks of 10, then use Promise.all on each chunk sequentially.

Solution

1. Step 1: Understand batch size control

   Sending all 100 requests at once may overload the server; batching limits concurrency.

2. Step 2: Implement batch processing

   Split URLs into groups of 10, then await Promise.all for each batch sequentially.

3. Final Answer:

   Split URLs into chunks of 10, then use Promise.all on each chunk sequentially. -> Option D

4. Quick Check:

   Batch requests in chunks with Promise.all = Split URLs into chunks of 10, then use Promise.all on each chunk sequentially. [OK]

Hint: Batch requests in small groups, await each batch [OK]

Common Mistakes:

• Sending all requests at once causing overload
• Not awaiting async calls properly
• Sending requests one by one losing async benefits