Why batch operations reduce round trips in Rest API - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding batch operations and network round trips

Why do batch operations reduce the number of network round trips in REST APIs?

A Because batch operations combine multiple requests into one, reducing the number of separate network calls.

B Because batch operations compress data to make each request smaller.

C Because batch operations use a faster network protocol than normal requests.

D Because batch operations cache responses locally to avoid sending requests.

💡 Hint

Think about how sending many small packages compares to sending one big package.

Batch operations group multiple requests into a single network call, which means fewer trips back and forth between client and server. This reduces latency and overhead.

❓ Predict Output

intermediate

Output of batch request simulation

Consider this Python code simulating batch vs single requests. What is the output?

Rest API

import time

def single_requests(n):
    total_time = 0
    for _ in range(n):
        time.sleep(0.1)  # simulate network delay
        total_time += 0.1
    return total_time

def batch_request(n):
    time.sleep(0.1)  # simulate one batch delay
    return 0.1

print(f"Single requests total time: {single_requests(5)} seconds")
print(f"Batch request total time: {batch_request(5)} seconds")

A

Single requests total time: 0.5 seconds
Batch request total time: 0.5 seconds

B

Single requests total time: 0.5 seconds
Batch request total time: 0.1 seconds

C

Single requests total time: 0.1 seconds
Batch request total time: 0.5 seconds

D

Single requests total time: 0.1 seconds
Batch request total time: 0.1 seconds

💡 Hint

Each single request waits 0.1 seconds, batch waits once.

Five single requests each wait 0.1 seconds, totaling 0.5 seconds. The batch request waits only once for 0.1 seconds.

❓ Predict Output

advanced

What is the output of this batch API call simulation?

Given this JavaScript code simulating batch API calls, what is logged?

Rest API

async function simulateBatch() {
  const delay = ms => new Promise(res => setTimeout(res, ms));
  async function singleCall(id) {
    await delay(100);
    return `Response ${id}`;
  }
  async function batchCall(ids) {
    await delay(100);
    return ids.map(id => `Response ${id}`);
  }

  const singleResults = [];
  for (let i = 1; i <= 3; i++) {
    singleResults.push(await singleCall(i));
  }

  const batchResults = await batchCall([1, 2, 3]);

  console.log(singleResults);
  console.log(batchResults);
}
simulateBatch();

A

["Response 1", "Response 2", "Response 3"]
["Response 1", "Response 2", "Response 3"]

B

["Response 3"]
["Response 1", "Response 2", "Response 3"]

C

["Response 1"]
["Response 1", "Response 2", "Response 3"]

D

["Response 1", "Response 2", "Response 3"]
["Response 3"]

💡 Hint

Both single and batch calls return arrays of responses for ids 1 to 3.

The single calls collect responses one by one into an array. The batch call returns an array of all responses at once. Both arrays contain the same three responses.

🧠 Conceptual

advanced

Why batch operations improve API efficiency beyond fewer round trips

Besides reducing the number of network round trips, what is another key reason batch operations improve API efficiency?

A They automatically retry failed requests without client intervention.

B They encrypt data more securely than single requests.

C They reduce server processing overhead by handling multiple requests together.

D They guarantee faster database queries by caching results.

💡 Hint

Think about how handling many requests at once can save work on the server side.

Batch operations let the server process multiple requests in one go, reducing repeated setup and teardown work, which saves resources and time.

🚀 Application

expert

Calculate total network time with and without batching

You have 10 API calls. Each call takes 50ms network latency plus 100ms server processing. If you batch all calls into one request, the network latency is 50ms once and server processing is 100ms times 10 calls. What is the total time difference between batching and sending calls individually?

A Batching takes 500ms, individual calls take 1000ms, so batching saves 500ms.

B Batching takes 550ms, individual calls take 1500ms, so batching saves 950ms.

C Batching takes 1050ms, individual calls take 1050ms, so no time is saved.

D Batching takes 1050ms, individual calls take 1500ms, so batching saves 450ms.

💡 Hint

Calculate total time for individual calls: (latency + processing) * number of calls. For batch: latency once + processing for all calls.

Individual calls: (50ms + 100ms) * 10 = 1500ms. Batch call: 50ms + (100ms * 10) = 1050ms. Difference is 450ms saved by batching.