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.