TransactWriteItems in DynamoDB - Step-by-Step Execution

Concept Flow - TransactWriteItems

Start Transaction

↓

Prepare Write Requests

↓

Send TransactWriteItems API Call

↓

DynamoDB Checks All Conditions

↓

If All Conditions Pass

→Apply All Writes Atomically

↓

If Any Condition Fails

→Abort All Writes

This flow shows how TransactWriteItems sends multiple write requests as one transaction. DynamoDB checks all conditions and either applies all writes together or none.

Execution Sample

DynamoDB

TransactWriteItems(
  TransactItems=[
    {Put: {TableName: 'Users', Item: {UserID: '123', Name: 'Alice'}}},
    {Update: {TableName: 'Orders', Key: {OrderID: 'abc'}, UpdateExpression: 'SET #S = :s', ExpressionAttributeNames: {'#S': 'Status'}, ExpressionAttributeValues: {':s': 'Shipped'}}}
  ]
)

This code sends a transaction to put a new user and update an order status atomically.

Execution Table

Step	Action	Condition Check	Result	Transaction State
1	Prepare Put request for Users table	N/A	Request ready	Pending
2	Prepare Update request for Orders table	N/A	Request ready	Pending
3	Send TransactWriteItems API call	N/A	Requests sent	Pending
4	DynamoDB checks conditions for Put	No condition or passes	Pass	Pending
5	DynamoDB checks conditions for Update	Condition passes	Pass	Pending
6	All conditions passed	N/A	Apply all writes atomically	Committed
7	Return success response	N/A	Transaction successful	Committed

💡 Transaction ends after all conditions pass and writes are applied atomically.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 6	Final
TransactionState	None	Pending	Pending	Committed	Committed
PutRequestStatus	Not prepared	Ready	Ready	Applied	Applied
UpdateRequestStatus	Not prepared	Not prepared	Ready	Applied	Applied

Key Moments - 2 Insights

Why does the transaction fail if one condition check fails?

Because TransactWriteItems ensures all writes succeed together or none at all, so if any condition fails (see Step 5 in execution_table), DynamoDB aborts the entire transaction to keep data consistent.

Are the writes applied one by one or all at once?

All writes are applied atomically at once after all conditions pass (see Step 6), so either all changes happen or none do.

Visual Quiz - 3 Questions

Look at the execution_table, what is the TransactionState after Step 2?

A Pending

B Committed

C Failed

D Not started

💡 Hint

Check the 'Transaction State' column in row for Step 2.

At which step does DynamoDB apply all writes atomically?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

Look for the step where 'Apply all writes atomically' happens in the 'Result' column.

If the condition check for the Update request fails, what happens to the transaction?

A Transaction commits only the Put request

B Transaction aborts all writes

C Transaction retries automatically

D Transaction commits only the Update request

💡 Hint

Refer to the key_moments section and the flow where any condition failure aborts the transaction.

Concept Snapshot

TransactWriteItems lets you send multiple write requests as one atomic transaction.
All conditions must pass for writes to apply.
If any condition fails, all writes are aborted.
Use it to keep multiple items consistent in DynamoDB.
Syntax: TransactWriteItems(TransactItems=[{Put|Update|Delete}...])

Full Transcript

TransactWriteItems in DynamoDB allows you to group multiple write operations into a single transaction. The process starts by preparing each write request, such as Put or Update. Then, the TransactWriteItems API call sends all requests together. DynamoDB checks all conditions for each write. If all conditions pass, it applies all writes atomically, meaning all changes happen together. If any condition fails, DynamoDB aborts the entire transaction to keep data consistent. This ensures either all changes are saved or none are, avoiding partial updates. The transaction state moves from pending to committed only after successful writes. This method is useful when you want to update multiple items reliably in one go.

Practice

1. What is the main purpose of TransactWriteItems in DynamoDB?

easy

A. To group multiple write operations into a single atomic transaction

B. To read multiple items from different tables at once

C. To create a backup of the database automatically

D. To perform batch deletes without conditions

Solution

1. Step 1: Understand the role of TransactWriteItems

   TransactWriteItems groups multiple write actions (Put, Update, Delete) into one atomic transaction.

2. Step 2: Compare with other options

   It does not perform reads, backups, or unconditional batch deletes.

3. Final Answer:

   To group multiple write operations into a single atomic transaction -> Option A

4. Quick Check:

   Atomic transaction = group writes together [OK]

Hint: Remember: TransactWriteItems groups writes atomically [OK]

Common Mistakes:

• Confusing TransactWriteItems with batch read operations
• Thinking it automatically backs up data
• Assuming it only deletes items

2. Which of the following is the correct syntax structure for a TransactWriteItems request in DynamoDB?

easy

A. { TransactWriteItems: [{ Get: { TableName: 'MyTable', Key: {...} } }] }

B. { BatchWriteItems: [{ PutRequest: {...} }, { DeleteRequest: {...} }] }

C. { TransactItems: [{ Put: { TableName: 'MyTable', Item: {...} } }, { Update: {...} }] }

D. { WriteItems: [{ Put: {...} }, { Update: {...} }] }

Solution

1. Step 1: Identify correct TransactWriteItems syntax

   The correct syntax uses the key 'TransactItems' with an array of actions like Put and Update.

2. Step 2: Eliminate incorrect options

   BatchWriteItems is a different API; Get is not a write action; WriteItems is not a valid key.

3. Final Answer:

   { TransactItems: [{ Put: { TableName: 'MyTable', Item: {...} } }, { Update: {...} }] } -> Option C

4. Quick Check:

   TransactItems with Put/Update = correct syntax [OK]

Hint: Look for 'TransactItems' key with write actions inside [OK]

Common Mistakes:

• Using BatchWriteItems instead of TransactWriteItems
• Including Get operations inside TransactWriteItems
• Using incorrect key names like WriteItems

3. Given the following TransactWriteItems request, what will happen if the condition in the Update action fails?

{
  TransactItems: [
    { Put: { TableName: 'Users', Item: { UserId: '123', Name: 'Alice' } } },
    { Update: { TableName: 'Users', Key: { UserId: '123' }, UpdateExpression: 'SET Age = :age', ConditionExpression: 'attribute_exists(UserId)', ExpressionAttributeValues: { ':age': 30 } } }
  ]
}

medium

A. Put action succeeds; Update action is skipped

B. Both actions succeed regardless of the condition

C. Update action succeeds; Put action is skipped

D. Both Put and Update actions are rolled back; no changes are applied

Solution

1. Step 1: Understand TransactWriteItems atomicity

   All actions in TransactWriteItems succeed or all fail together as one transaction.

2. Step 2: Analyze condition failure effect

   If the Update's condition fails, the entire transaction rolls back, including the Put.

3. Final Answer:

   Both Put and Update actions are rolled back; no changes are applied -> Option D

4. Quick Check:

   Condition failure rolls back entire transaction [OK]

Hint: If any condition fails, whole TransactWriteItems rolls back [OK]

Common Mistakes:

• Assuming partial success when condition fails
• Thinking Put action always succeeds
• Ignoring atomicity of TransactWriteItems

4. You wrote this TransactWriteItems request but it fails with a syntax error:

{
  TransactItems: [
    { Put: { TableName: 'Orders', Item: { OrderId: '001', Status: 'Pending' } } },
    { Delete: { TableName: 'Orders', Key: { OrderId: '002' } } }
  ],
  ReturnConsumedCapacity: 'TOTAL'
}

What is the likely cause of the error?

medium

A. Delete action requires a ConditionExpression

B. Missing comma after the TransactItems array

C. TransactItems must be an object, not an array

D. TableName cannot be specified inside Put or Delete actions

Solution

1. Step 1: Check JSON syntax in the request

   ReturnConsumedCapacity is a valid parameter, but the JSON is invalid due to a missing comma after the closing bracket (]) of the TransactItems array.

2. Step 2: Validate other parts

   Delete and Put actions are correctly structured; TransactItems must be an array; TableName is required inside actions.

3. Final Answer:

   Missing comma after the TransactItems array -> Option B

4. Quick Check:

   JSON requires commas between object properties [OK]

Hint: Validate JSON syntax: add commas between top-level properties [OK]

Common Mistakes:

• Omitting commas in JSON request objects
• Forgetting TableName inside each action
• Misusing array vs object for TransactItems

5. You want to atomically update a user's email and delete a related temporary token in DynamoDB using TransactWriteItems. Which of the following request structures correctly achieves this?

hard

A. { TransactItems: [ { Update: { TableName: 'Users', Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e', ExpressionAttributeValues: { ':e': '[e-mail]' } } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ] }

B. { BatchWriteItems: [ { UpdateRequest: { Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e' } }, { DeleteRequest: { Key: { TokenId: 't1' } } } ] }

C. { TransactItems: [ { Put: { TableName: 'Users', Item: { UserId: 'u1', Email: '[e-mail]' } } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ] }

D. { TransactItems: [ { Update: { TableName: 'Users', Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e' } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ], ReturnValuesOnConditionCheckFailure: 'ALL_OLD' }

Solution

1. Step 1: Identify correct atomic update and delete

   { TransactItems: [ { Update: { TableName: 'Users', Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e', ExpressionAttributeValues: { ':e': '[e-mail]' } } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ] } uses TransactWriteItems with Update and Delete actions correctly structured.

2. Step 2: Eliminate incorrect options

   { BatchWriteItems: [ { UpdateRequest: { Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e' } }, { DeleteRequest: { Key: { TokenId: 't1' } } } ] } uses BatchWriteItems which does not support Update; { TransactItems: [ { Put: { TableName: 'Users', Item: { UserId: 'u1', Email: '[e-mail]' } } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ] } uses Put which replaces entire item, not update; { TransactItems: [ { Update: { TableName: 'Users', Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e' } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ], ReturnValuesOnConditionCheckFailure: 'ALL_OLD' } includes unsupported parameter ReturnValuesOnConditionCheckFailure.

3. Final Answer:

   { TransactItems: [ { Update: { TableName: 'Users', Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e', ExpressionAttributeValues: { ':e': '[e-mail]' } } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ] } -> Option A

4. Quick Check:

   Use Update and Delete inside TransactItems for atomic changes [OK]

Hint: Use Update and Delete inside TransactItems for atomic writes [OK]

Common Mistakes:

• Using BatchWriteItems for updates
• Using Put instead of Update to change attributes
• Adding unsupported parameters in TransactWriteItems