Why transactions ensure atomicity in DynamoDB - Performance Analysis

Time Complexity: Why transactions ensure atomicity

O(n)

Understanding Time Complexity

We want to understand how the time needed to complete a transaction changes as we add more operations inside it.

How does DynamoDB keep all parts of a transaction working together without partial changes?

Scenario Under Consideration

Analyze the time complexity of the following DynamoDB transaction code.

    const params = {
      TransactItems: [
        { Put: { TableName: 'Orders', Item: orderItem } },
        { Update: { TableName: 'Inventory', Key: inventoryKey, UpdateExpression: 'SET quantity = quantity - :dec', ExpressionAttributeValues: { ':dec': 1 } } }
      ]
    };
    await dynamodb.transactWrite(params).promise();
    

This code writes an order and updates inventory in one transaction, ensuring both succeed or fail together.

Identify Repeating Operations

Look for repeated actions inside the transaction.

• Primary operation: Each item write or update inside the transaction.
• How many times: Once per item in the TransactItems array.

How Execution Grows With Input

As you add more operations to the transaction, the time to complete it grows roughly in a straight line.

Input Size (n)	Approx. Operations
2	2 operations
5	5 operations
10	10 operations

Pattern observation: Each added operation adds a similar amount of work, so time grows steadily with the number of operations.

Final Time Complexity

Time Complexity: O(n)

This means the time to complete the transaction grows directly with the number of operations inside it.

Common Mistake

[X] Wrong: "Transactions always take the same time no matter how many operations they have."

[OK] Correct: Each operation inside the transaction adds work, so more operations mean more time.

Interview Connect

Understanding how transaction time grows helps you design efficient database operations and explain your choices clearly in conversations.

Self-Check

"What if the transaction included conditional checks on each item? How would that affect the time complexity?"