Why transactions ensure atomicity in DynamoDB - See It in Action

Understanding Atomicity with DynamoDB Transactions

📖 Scenario: You are managing an online bookstore's inventory and sales using DynamoDB. You want to ensure that when a customer buys a book, the stock count decreases and the sale record is created together, or not at all. This prevents errors like selling books that are out of stock.

🎯 Goal: Build a DynamoDB transaction that updates the stock count and adds a sale record atomically, so both actions succeed or fail together.

📋 What You'll Learn

Create a DynamoDB table named Books with items containing BookID and Stock attributes.

Create a DynamoDB table named Sales to record sales with SaleID, BookID, and Quantity attributes.

Write a transaction that decreases the Stock of a book by 1 and adds a sale record in the Sales table.

Ensure the transaction is atomic: both updates happen together or none happen if stock is insufficient.

💡 Why This Matters

🌍 Real World

Online stores must keep inventory accurate and sales records consistent. Transactions help avoid errors like selling out-of-stock items.

💼 Career

Understanding DynamoDB transactions is essential for backend developers working with AWS to build reliable, consistent data operations.

1

Create the Books table with initial stock

Create a DynamoDB table named Books and add an item with BookID set to "book123" and Stock set to 5.

DynamoDB

# Your code here to create Books table and add item with BookID 'book123' and Stock 5

Need a hint?

Use put_item on the Books table to add the book with stock 5.

2

Create the Sales table

Create a DynamoDB table named Sales to store sales records. Then prepare a variable called sales_table that references this table.

DynamoDB

import boto3

dynamodb = boto3.resource('dynamodb')

books_table = dynamodb.Table('Books')

books_table.put_item(Item={'BookID': 'book123', 'Stock': 5})

# Create Sales table and assign to sales_table variable

Need a hint?

Use dynamodb.Table('Sales') to get the Sales table reference.

3

Write the transaction to update stock and add sale

Use dynamodb.meta.client.transact_write_items to create a transaction that does two things atomically: (1) update the Stock of BookID "book123" by subtracting 1 only if current stock is greater than 0, and (2) put a new item in Sales with SaleID "sale001", BookID "book123", and Quantity 1.

DynamoDB

import boto3

dynamodb = boto3.resource('dynamodb')

books_table = dynamodb.Table('Books')
sales_table = dynamodb.Table('Sales')

books_table.put_item(Item={'BookID': 'book123', 'Stock': 5})

# Write transaction to update stock and add sale atomically

Need a hint?

Use transact_write_items with Update and Put actions. Use a condition to check stock > 0.

4

Complete the transaction with error handling

Add a try-except block around the transaction call to catch client.exceptions.TransactionCanceledException and print "Transaction failed: insufficient stock". This completes the atomic transaction logic with error handling.

DynamoDB

import boto3

dynamodb = boto3.resource('dynamodb')

books_table = dynamodb.Table('Books')
sales_table = dynamodb.Table('Sales')

books_table.put_item(Item={'BookID': 'book123', 'Stock': 5})

client = dynamodb.meta.client

# Add try-except block to handle transaction errors

try:
    # Your code here
except client.exceptions.TransactionCanceledException:
    print("Transaction failed: insufficient stock")

Need a hint?

Wrap the transaction call in a try-except block to catch TransactionCanceledException and handle it gracefully.