Transaction limits in DynamoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Maximum number of operations in a DynamoDB transaction

What is the maximum number of operations allowed in a single DynamoDB transaction?

A 10 operations

B 100 operations

C 50 operations

D 25 operations

💡 Hint

Think about the official AWS limits for transactional writes and reads.

DynamoDB transactions support up to 10 operations per transaction, including both reads and writes.

❓ query_result

intermediate

Result of exceeding transaction operation limit

What error will DynamoDB return if you try to execute a transaction with 12 operations?

A InternalServerError

B ValidationException with message 'Transaction size too large'

C TransactionCanceledException with reason 'Too many operations'

D ProvisionedThroughputExceededException

💡 Hint

Consider the error related to exceeding the allowed number of operations.

DynamoDB returns a ValidationException with message 'Transaction size too large' when the transaction exceeds the allowed number of operations.

📝 Syntax

advanced

Valid transaction request size in DynamoDB

Which of the following JSON snippets correctly respects the DynamoDB transaction limits for operations count and item size?

A { "TransactItems": [ { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "123" }, "Name": { "S": "Alice" }, "Bio": { "S": "A very long string exceeding 400 KB..." } } } } ] }

B { "TransactItems": [ { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "123" }, "Name": { "S": "Alice" } } } } ] }

C { "TransactItems": [ { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "123" }, "Name": { "S": "Alice" } } } }, { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "124" }, "Name": { "S": "Bob" } } } }, { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "125" }, "Name": { "S": "Charlie" } } } }, { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "126" }, "Name": { "S": "David" } } } }, { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "127" }, "Name": { "S": "Eve" } } } }, { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "128" }, "Name": { "S": "Frank" } } } }, { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "129" }, "Name": { "S": "Grace" } } } }, { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "130" }, "Name": { "S": "Hank" } } } }, { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "131" }, "Name": { "S": "Ivy" } } } }, { "Put": { "TableName": "Users", "Item": { "UserId": { "S": "132" }, "Name": { "S": "Jack" } } } } ] }

D { "TransactItems": [] }

💡 Hint

Remember the max operations per transaction and item size limits.

Option C contains exactly 10 operations, each with a small item size, respecting DynamoDB transaction limits. Option C has only 1 operation (valid but less than max), C exceeds item size limit, D has zero operations which is invalid.

❓ optimization

advanced

Optimizing transaction usage under DynamoDB limits

You need to update 25 items atomically in DynamoDB. Given the transaction operation limit, what is the best approach?

A Split the updates into 3 transactions with 10, 10, and 5 operations each

B Use a single transaction with all 25 operations

C Update all items individually without transactions

D BatchWriteItem API with 25 items in one batch

💡 Hint

Consider the maximum operations per transaction and atomicity requirements.

DynamoDB transactions support up to 10 operations. To update 25 items atomically in groups, split into multiple transactions. BatchWriteItem does not guarantee atomicity.

🔧 Debug

expert

Diagnosing transaction failure due to size limits

A DynamoDB transaction with 8 operations fails with TransactionCanceledException. The items are small, but the transaction includes a condition expression on one item that is very large. What is the most likely cause?

A The provisioned throughput is exceeded

B The transaction has more than 10 operations

C The table does not exist

D The total size of all condition expressions exceeds the 4 MB transaction size limit

💡 Hint

Think about transaction size limits including condition expressions.

DynamoDB transactions have a 4 MB total size limit including items and condition expressions. Large condition expressions can cause failure even if item sizes are small.

Practice

1. What is the maximum number of operations allowed in a single TransactWriteItems request in DynamoDB?

easy

A. 50 operations

B. 25 operations

C. 5 operations

D. 10 operations

Solution

1. Step 1: Understand DynamoDB transaction limits

   DynamoDB limits the number of operations in a transaction to ensure performance and consistency.

2. Step 2: Recall the specific limit for TransactWriteItems

   The limit for TransactWriteItems is 10 operations per transaction.

3. Final Answer:

   10 operations -> Option D

4. Quick Check:

   TransactWriteItems max ops = 10 [OK]

Hint: Remember: Write transactions allow up to 10 ops only [OK]

Common Mistakes:

• Confusing write and read transaction limits
• Assuming more than 10 operations are allowed in write transactions
• Mixing up TransactWriteItems with TransactGetItems limits

2. Which of the following is the correct syntax to start a transaction with multiple write operations in DynamoDB using TransactWriteItems?

easy

A. dynamodb.transactWriteItems({ Items: [...] })

B. dynamodb.transactWriteItems({ TransactItems: [...] })

C. dynamodb.transactWrite({ Operations: [...] })

D. dynamodb.transactWrite({ Items: [...] })

Solution

1. Step 1: Identify the correct parameter name for transaction items

   The DynamoDB API for TransactWriteItems requires the parameter TransactItems to specify operations.

2. Step 2: Match the syntax with the correct parameter

   Only dynamodb.transactWriteItems({ TransactItems: [...] }) uses TransactItems correctly inside the method call.

3. Final Answer:

   dynamodb.transactWriteItems({ TransactItems: [...] }) -> Option B

4. Quick Check:

   Use TransactItems for write transactions [OK]

Hint: Look for 'TransactItems' key in write transaction syntax [OK]

Common Mistakes:

• Using 'Items' instead of 'TransactItems'
• Calling a non-existent method like 'transactWrite'
• Confusing parameter names for transaction operations

3. Consider a DynamoDB transaction using TransactGetItems with 30 get operations. What will happen when this transaction is executed?

medium

A. The transaction fails because it exceeds the 25 operation limit

B. The transaction succeeds and returns all 30 items

C. Only the first 25 items are returned, others ignored

D. The transaction partially succeeds with a warning

Solution

1. Step 1: Recall the operation limit for TransactGetItems

   DynamoDB limits TransactGetItems to a maximum of 25 operations per transaction.

2. Step 2: Analyze the effect of exceeding the limit

   Submitting 30 operations exceeds this limit, causing the entire transaction to fail.

3. Final Answer:

   The transaction fails because it exceeds the 25 operation limit -> Option A

4. Quick Check:

   TransactGetItems max ops = 25 [OK]

Hint: TransactGetItems max 25 ops; more causes failure [OK]

Common Mistakes:

• Assuming partial success with extra operations
• Thinking the limit is 30 or more
• Believing the transaction truncates results automatically

4. You wrote a DynamoDB transaction with 12 write operations inside TransactWriteItems. The transaction fails. What is the most likely cause?

medium

A. Exceeded the maximum of 25 operations allowed in TransactWriteItems

B. Exceeded the maximum size of 4 MB per item

C. Exceeded the maximum of 10 operations allowed in TransactWriteItems

D. Used incorrect parameter name 'Items' instead of 'TransactItems'

Solution

1. Step 1: Check the operation count limit for TransactWriteItems

   The maximum allowed operations in TransactWriteItems is 10.

2. Step 2: Identify the cause of failure with 12 operations

   Since 12 exceeds 10, the transaction fails due to exceeding the operation limit.

3. Final Answer:

   Exceeded the maximum of 10 operations allowed in TransactWriteItems -> Option C

4. Quick Check:

   More than 10 ops in write transaction causes failure [OK]

Hint: More than 10 writes in transaction causes failure [OK]

Common Mistakes:

• Confusing operation count with item size limits
• Assuming 25 ops limit applies to write transactions
• Ignoring parameter name errors as cause

5. You want to perform a transaction that reads 20 items and writes 8 items atomically in DynamoDB. How should you structure your requests to stay within transaction limits?

hard

A. Use one TransactWriteItems with 8 writes and one TransactGetItems with 20 reads separately

B. Use a single TransactWriteItems with 28 operations combining reads and writes

C. Use one TransactGetItems with 20 reads and add 8 writes to it

D. Use a single TransactGetItems with 28 operations combining reads and writes

Solution

1. Step 1: Understand separate transaction types and their limits

   DynamoDB separates read and write transactions: TransactWriteItems for writes (max 10 ops), TransactGetItems for reads (max 25 ops).

2. Step 2: Plan transactions to respect limits

   Perform writes (8 ops) in one TransactWriteItems and reads (20 ops) in one TransactGetItems to stay within limits.

3. Final Answer:

   Use one TransactWriteItems with 8 writes and one TransactGetItems with 20 reads separately -> Option A

4. Quick Check:

   Separate read/write transactions to respect limits [OK]

Hint: Split reads and writes into separate transactions [OK]

Common Mistakes:

• Trying to combine reads and writes in one transaction
• Exceeding operation limits by mixing types
• Assuming one transaction can handle both reads and writes