Why messaging services matter in AWS - Performance Analysis

Time Complexity: Why messaging services matter

O(n)

Understanding Time Complexity

We want to understand how the time to send messages grows as we send more messages using AWS messaging services.

How does the number of messages affect the total time and operations needed?

Scenario Under Consideration

Analyze the time complexity of the following operation sequence.

// Send multiple messages to an AWS SQS queue
const AWS = require('aws-sdk');
const sqs = new AWS.SQS();

async function sendMessages(messages) {
  for (const msg of messages) {
    await sqs.sendMessage({ QueueUrl: 'QUEUE_URL', MessageBody: msg }).promise();
  }
}
    

This code sends each message one by one to an SQS queue, waiting for each send to finish before starting the next.

Identify Repeating Operations

Identify the API calls, resource provisioning, data transfers that repeat.

• Primary operation: The sendMessage API call to SQS.
• How many times: Once for each message in the input list.

How Execution Grows With Input

Each message requires one API call, so as the number of messages grows, the total calls grow at the same rate.

Input Size (n)	Approx. API Calls/Operations
10	10
100	100
1000	1000

Pattern observation: The number of API calls grows directly with the number of messages.

Final Time Complexity

Time Complexity: O(n)

This means the time and number of operations grow linearly as you send more messages.

Common Mistake

[X] Wrong: "Sending multiple messages at once takes the same time as sending one message."

[OK] Correct: Each message requires its own API call, so sending more messages takes more time and operations.

Interview Connect

Understanding how messaging scales helps you design systems that handle growing workloads smoothly and predict costs.

Self-Check

"What if we used batch sending instead of single sends? How would the time complexity change?"