Async batch processing in Rest API - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is async batch processing in the context of REST APIs?

Async batch processing allows a client to send a large set of requests to a server and receive a response later, enabling the server to process the batch without blocking the client.

beginner

Why use async batch processing instead of synchronous requests?

It improves performance by not making the client wait for all operations to finish, reduces server load spikes, and handles large data sets efficiently.

intermediate

What is a common pattern for implementing async batch processing in REST APIs?

Clients send a batch request and receive a job ID. They then poll or get notified when the batch processing is complete to retrieve results.

intermediate

How does polling work in async batch processing?

The client repeatedly asks the server if the batch job is done by sending requests with the job ID until the server responds with the results.

intermediate

Name one advantage and one disadvantage of async batch processing.

Advantage: It frees the client from waiting and improves scalability. Disadvantage: It requires extra logic for job tracking and result retrieval.

What does async batch processing help to avoid in REST APIs?

A Making the client wait for all requests to finish

B Sending requests one by one

C Using HTTP GET method

D Encrypting data

Async batch processing avoids making the client wait for all requests to finish by processing them in the background.

In async batch processing, what does the server usually return immediately after receiving a batch request?

A The final results

B A job ID to track progress

C An error message

D The full batch data

The server returns a job ID so the client can check later when the batch processing is done.

Which method is commonly used by clients to check if batch processing is complete?

A Using WebSocket only

B Sending a new batch request

C Closing the connection

D Polling the server with the job ID

Clients poll the server with the job ID to check if the batch job is finished.

What is a disadvantage of async batch processing?

A It requires extra logic for job tracking

B It uses too much bandwidth

C It cannot handle large data

D It blocks the client

Async batch processing needs extra logic to track jobs and retrieve results later.

Which scenario is best suited for async batch processing?

A Small, quick requests

B Real-time chat messages

C Large data sets needing long processing

D Simple static page requests

Async batch processing is ideal for large data sets that take time to process.

Explain how async batch processing works in a REST API from sending the request to getting the results.

Think about how the client and server communicate over time.

List the benefits and challenges of using async batch processing in REST APIs.

Consider what async batch processing helps with and what extra work it requires.

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