What is Transaction in DynamoDB: Explanation and Example

A transaction in DynamoDB is a way to perform multiple read or write operations atomically, meaning all operations succeed or none do. It ensures data consistency by grouping actions like PutItem, UpdateItem, or DeleteItem into a single all-or-nothing operation.

How It Works

Think of a transaction in DynamoDB like a group of tasks you want to complete together. Imagine you are moving money between two bank accounts. You want to make sure the money is taken from one account and added to the other at the same time. If one part fails, you don't want the other to happen alone.

In DynamoDB, a transaction bundles multiple operations such as adding, updating, or deleting items. These operations either all succeed together or all fail, so your data stays correct and consistent. This is important when you need to keep related data in sync.

Behind the scenes, DynamoDB uses a two-phase commit process to ensure that either all changes are applied or none are, even if there are errors or interruptions.

Example

This example shows how to use a transaction to update two items atomically in DynamoDB using AWS SDK for JavaScript.

javascript

import { DynamoDBClient, TransactWriteItemsCommand } from "@aws-sdk/client-dynamodb";

const client = new DynamoDBClient({ region: "us-east-1" });

async function runTransaction() {
  const params = {
    TransactItems: [
      {
        Update: {
          TableName: "Accounts",
          Key: { "AccountId": { S: "123" } },
          UpdateExpression: "SET Balance = Balance - :amount",
          ExpressionAttributeValues: { ":amount": { N: "100" } },
          ConditionExpression: "Balance >= :amount"
        }
      },
      {
        Update: {
          TableName: "Accounts",
          Key: { "AccountId": { S: "456" } },
          UpdateExpression: "SET Balance = Balance + :amount",
          ExpressionAttributeValues: { ":amount": { N: "100" } }
        }
      }
    ]
  };

  try {
    await client.send(new TransactWriteItemsCommand(params));
    console.log("Transaction succeeded: money transferred.");
  } catch (error) {
    console.error("Transaction failed:", error);
  }
}

runTransaction();

Output

Transaction succeeded: money transferred.

When to Use

Use transactions in DynamoDB when you need to make sure multiple changes happen together or not at all. This is important for financial operations, inventory management, or any case where data consistency is critical.

For example, transferring money between accounts, reserving seats for an event, or updating related records in different tables all benefit from transactions. Without transactions, partial updates could leave your data in an incorrect state.

Key Points

• Transactions group multiple operations into a single atomic action.
• All operations succeed or all fail together, ensuring data consistency.
• DynamoDB supports transactions for up to 25 items or 4 MB of data.
• Transactions use a two-phase commit behind the scenes.
• Use transactions for critical updates that must stay in sync.

Key Takeaways

DynamoDB transactions ensure multiple operations succeed or fail as one unit.

Use transactions to keep related data consistent and avoid partial updates.

Transactions support up to 25 items or 4 MB of data per request.

Behind the scenes, DynamoDB uses a two-phase commit to guarantee atomicity.

Ideal for financial transfers, inventory updates, and other critical workflows.