Async batch processing in Rest API - Mini Project: Build & Apply

Async Batch Processing with REST API

📖 Scenario: You are building a REST API that processes a batch of tasks asynchronously. This is useful when you have many tasks to run but don't want to block the client while waiting for all tasks to finish.Imagine a system that receives a list of job IDs and processes each job in the background, returning a batch ID immediately. Later, the client can check the batch status or results.

🎯 Goal: Create a simple REST API with endpoints to submit a batch of jobs for asynchronous processing, track their progress, and retrieve results.

📋 What You'll Learn

Create an endpoint /submit_batch that accepts a JSON list of job IDs and returns a batch ID immediately.

Store the batch jobs and their statuses in a dictionary.

Process each job asynchronously with a simulated delay.

Create an endpoint /batch_status that returns the status of all jobs in a batch.

Create an endpoint /batch_results that returns the results of all completed jobs in a batch.

💡 Why This Matters

🌍 Real World

Async batch processing is common in web services that handle many tasks without blocking clients, such as image processing, data import, or sending emails.

💼 Career

Understanding async batch processing is valuable for backend developers, API designers, and anyone working with scalable web applications or microservices.

1

Setup initial data structures

Create a dictionary called batches to store batch information. Each batch will have a unique ID as key and a dictionary with job statuses as value. Also, create a variable batch_counter initialized to 0 to generate batch IDs.

Rest API

# Your code here

Hint

Use a dictionary for batches and an integer batch_counter starting at 0.

2

Create batch submission endpoint

Write a function submit_batch(job_ids) that increments batch_counter, creates a new entry in batches with the new batch ID, and initializes each job ID with status 'pending'. Return the new batch ID.

Rest API

batches = {}
batch_counter = 0

# Write submit_batch(job_ids) function here
# Your code here

Hint

Use a dictionary comprehension to set each job's status to 'pending'. Remember to declare batch_counter as global to modify it.

3

Process jobs asynchronously

Write an async function process_batch(batch_id) that loops over each job in batches[batch_id], simulates processing with await asyncio.sleep(1), and updates the job status to 'done'.

Rest API

batches = {}
batch_counter = 0

def submit_batch(job_ids):
    global batch_counter
    batch_counter += 1
    batch_id = batch_counter
    batches[batch_id] = {job_id: 'pending' for job_id in job_ids}
    return batch_id

import asyncio

# Write async process_batch(batch_id) function here
# Your code here

Hint

Use async def and await asyncio.sleep(1) to simulate asynchronous processing.

4

Display batch status and results

Write two functions: batch_status(batch_id) that returns the dictionary of job statuses for the batch, and batch_results(batch_id) that returns a list of job IDs with status 'done'. Then, print the status and results for batch ID 1 after processing it asynchronously.

Rest API

batches = {}
batch_counter = 0

def submit_batch(job_ids):
    global batch_counter
    batch_counter += 1
    batch_id = batch_counter
    batches[batch_id] = {job_id: 'pending' for job_id in job_ids}
    return batch_id

import asyncio

async def process_batch(batch_id):
    for job_id in batches[batch_id]:
        await asyncio.sleep(1)  # simulate job processing
        batches[batch_id][job_id] = 'done'

# Write batch_status(batch_id) and batch_results(batch_id) functions
# Then submit a batch with job IDs [101, 102, 103], process it, and print status and results
# Your code here

Hint

Use dictionary get method to safely access batches. Use list comprehension to filter jobs with status 'done'. Use asyncio.run(main()) to run the async main function.

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