Why cost management prevents surprises in DynamoDB - Performance Analysis

Time Complexity: Why cost management prevents surprises

O(n)

Understanding Time Complexity

When using DynamoDB, managing costs well helps avoid unexpected charges.

We want to understand how the cost grows as we use more resources.

Scenario Under Consideration

Analyze the time complexity of this DynamoDB query with cost management in mind.

// Query to get items with a specific partition key
const params = {
  TableName: "Orders",
  KeyConditionExpression: "CustomerId = :cid",
  ExpressionAttributeValues: {
    ":cid": { S: "12345" }
  },
  Limit: 100
};

const data = await dynamodb.query(params).promise();
    

This code fetches up to 100 orders for one customer from the Orders table.

Identify Repeating Operations

Look for repeated actions that affect cost and time.

• Primary operation: Reading items from the database matching the query.
• How many times: Up to 100 items are read in one query call.

How Execution Grows With Input

As the number of items requested grows, the work and cost grow too.

Input Size (n)	Approx. Operations
10	10 item reads
100	100 item reads
1000	1000 item reads (may need multiple query calls)

Pattern observation: More items requested means more reads, so cost and time increase roughly in direct proportion.

Final Time Complexity

Time Complexity: O(n)

This means the time and cost grow linearly with the number of items you read.

Common Mistake

[X] Wrong: "Querying more items doesn't affect cost much because it's just one query call."

[OK] Correct: Each item read counts toward cost and time, so reading more items increases both directly.

Interview Connect

Understanding how cost grows with data size helps you design efficient queries and avoid surprises in real projects.

Self-Check

"What if we added a filter to reduce the number of items returned? How would that affect the time complexity?"