DynamoDB Tutorial for Beginners: A Hands-on Guide in 2025

Introduction

Amazon DynamoDB has become one of the most popular NoSQL databases for building modern applications due to its scalability, performance, and fully managed nature. Whether you’re developing a mobile app, web service, or IoT solution, understanding DynamoDB is an increasingly valuable skill for developers.

This beginner-friendly tutorial will guide you through the fundamentals of DynamoDB with hands-on examples. By the end, you’ll have practical experience creating tables, managing data, and implementing common patterns to build efficient DynamoDB-powered applications.

What You’ll Learn

• Setting up DynamoDB (both in AWS and locally for development)
• Creating tables with appropriate key structures
• Performing basic CRUD operations (Create, Read, Update, Delete)
• Querying and filtering data effectively
• Implementing common data access patterns
• Following best practices for performance and cost optimization

Prerequisites

• An AWS account (free tier eligible)
• Basic understanding of databases and JSON
• Familiarity with at least one programming language (examples will use JavaScript with Node.js)
• AWS CLI installed (optional but recommended)

Section 1: Getting Started with DynamoDB

Before diving into code, let’s understand what makes DynamoDB different from traditional databases and set up our environment.

Understanding DynamoDB Basics

DynamoDB is a fully managed NoSQL database that provides consistent, single-digit millisecond performance at any scale. Unlike relational databases, DynamoDB is:

• Serverless: No database servers to manage or provision
• Schemaless: Items in the same table can have different attributes
• Horizontally scalable: Automatically scales to handle any amount of traffic
• Distributed: Data is automatically replicated across multiple availability zones

The fundamental building blocks of DynamoDB are:

• Tables: Similar to tables in other databases, containing items
• Items: Individual records in a table (similar to rows in a relational database)
• Attributes: Data elements of an item (similar to columns, but can vary between items)
• Primary Keys: Unique identifiers for items, consisting of:
  • Partition Key: Determines data distribution (required)
  • Sort Key: Enables sorting within a partition (optional)

Setting Up DynamoDB

You have two options for working with DynamoDB:

Option 1: Using AWS DynamoDB Service

1. Sign in to your AWS account
2. Navigate to the DynamoDB service in the AWS Management Console
3. Ensure you’re in your preferred region (top-right corner)

Option 2: Running DynamoDB Locally (Recommended for Development)

For development and testing, you can run DynamoDB locally on your machine:

1. Download the DynamoDB local JAR file
2. Start the local instance:

# Create a directory for DynamoDB data
mkdir dynamodb-local-data

# Start DynamoDB local with the directory as storage
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb -dbPath ./dynamodb-local-data

You should see output indicating that DynamoDB is running on port 8000.

For more detailed instructions, check our guide on Running DynamoDB Locally.

Setting Up AWS SDK

To interact with DynamoDB programmatically, you’ll need the AWS SDK. Let’s set it up with Node.js:

1. Create a new directory for your project:

mkdir dynamodb-tutorial
cd dynamodb-tutorial
npm init -y

2. Install the AWS SDK for JavaScript v3:

npm install @aws-sdk/client-dynamodb @aws-sdk/lib-dynamodb

3. Create a file named config.js with your AWS configuration:

// config.js
const config = {
  region: 'us-east-1',  // Replace with your preferred region
  // For local development with DynamoDB local:
  endpoint: process.env.NODE_ENV === 'development'
    ? 'http://localhost:8000'
    : undefined,
  // Credentials are automatically loaded from environment
  // variables or AWS config when deployed
};

export default config;

Section 2: Creating Your First DynamoDB Table

Dynomate: Modern DynamoDB GUI Client

Built for real developer workflows with AWS profile integration, multi-session support, and team collaboration.

AWS SSO support & multi-region browsing

Script-like operations with data chaining

Git-friendly local storage for team sharing

Download Free TrialCompare GUI Clients

No account needed. Install and start using immediately.

• Table browsing across regions
• Flexible query & scan interface
• AWS API logging & debugging

Now that we have our environment set up, let’s create our first DynamoDB table. We’ll build a simple product catalog for an e-commerce application.

Table Design Considerations

Before creating a table, we need to consider:

1. Primary Key Structure: Simple (partition key only) or composite (partition key + sort key)
2. Access Patterns: How we’ll query and update the data
3. Attribute Structure: What data we’ll store for each item

For our product catalog, we’ll use:

• Partition Key: ProductId (unique identifier for each product)
• Attributes: Name, Description, Price, Category, etc.

Creating a Table via AWS Console

If you prefer a visual interface:

1. Open the AWS Management Console and navigate to DynamoDB
2. Click “Create table”
3. Enter “Products” as the table name
4. For the partition key, enter “ProductId” with type “String”
5. Leave the default settings and click “Create table”

Creating a Table Programmatically

Alternatively, you can create the table with code:

// create-table.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  CreateTableCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function createProductsTable() {
  const params = {
    TableName: "Products",
    KeySchema: [
      { AttributeName: "ProductId", KeyType: "HASH" } // Partition key
    ],
    AttributeDefinitions: [
      { AttributeName: "ProductId", AttributeType: "S" }
    ],
    ProvisionedThroughput: {
      ReadCapacityUnits: 5,
      WriteCapacityUnits: 5
    }
  };

  try {
    const data = await docClient.send(new CreateTableCommand(params));
    console.log("Table created successfully", data);
    return data;
  } catch (err) {
    console.error("Error creating table:", err);
    throw err;
  }
}

createProductsTable();

Run the script with:

node create-table.js

Understanding Table States and Settings

After creating a table, it will be in the “CREATING” state before becoming “ACTIVE.” You can check its status in the console or programmatically.

The table settings include:

• Provisioned Capacity: Read and write capacity units (RCUs and WCUs)
• On-Demand Capacity: Pay-per-request alternative to provisioned capacity
• Encryption: All data is encrypted at rest by default
• Time to Live (TTL): Optional automatic deletion of expired items
• Streams: Optional change data capture for event-driven applications

Section 3: Basic CRUD Operations

Now let’s implement the fundamental operations for working with data: Create, Read, Update, and Delete.

Adding Items to Your Table

Let’s add some products to our catalog:

// add-products.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  PutCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function addProduct(product) {
  const params = {
    TableName: "Products",
    Item: product
  };

  try {
    await docClient.send(new PutCommand(params));
    console.log(`Added product: ${product.ProductId}`);
  } catch (err) {
    console.error("Error adding product:", err);
    throw err;
  }
}

// Let's add a few products
const products = [
  {
    ProductId: "P001",
    Name: "Wireless Headphones",
    Description: "Premium noise-canceling wireless headphones",
    Price: 199.99,
    Category: "Electronics",
    InStock: true,
    DateAdded: new Date().toISOString()
  },
  {
    ProductId: "P002",
    Name: "Smart Watch",
    Description: "Fitness tracking smartwatch with heart rate monitor",
    Price: 249.99,
    Category: "Electronics",
    InStock: true,
    DateAdded: new Date().toISOString()
  },
  {
    ProductId: "P003",
    Name: "Ergonomic Chair",
    Description: "Adjustable office chair with lumbar support",
    Price: 299.99,
    Category: "Furniture",
    InStock: false,
    DateAdded: new Date().toISOString()
  }
];

async function addSampleProducts() {
  for (const product of products) {
    await addProduct(product);
  }
}

addSampleProducts();

Run the script:

node add-products.js

Reading Items from Your Table

Now let’s retrieve data from our table:

// read-product.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  GetCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function getProduct(productId) {
  const params = {
    TableName: "Products",
    Key: {
      ProductId: productId
    }
  };

  try {
    const response = await docClient.send(new GetCommand(params));
    if (response.Item) {
      console.log("Product found:", response.Item);
      return response.Item;
    } else {
      console.log("Product not found");
      return null;
    }
  } catch (err) {
    console.error("Error getting product:", err);
    throw err;
  }
}

// Get a product by ID
getProduct("P001");

Run the script:

node read-product.js

Updating Items

Let’s update an existing product:

// update-product.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  UpdateCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function updateProduct(productId, updates) {
  // Build the update expression and attribute values
  let updateExpression = "SET";
  const expressionAttributeValues = {};
  const expressionAttributeNames = {};

  Object.entries(updates).forEach(([key, value], index) => {
    const attributeValueKey = `:val${index}`;
    const attributeNameKey = `#attr${index}`;

    updateExpression += index === 0 ? ` ` : `, `;
    updateExpression += `${attributeNameKey} = ${attributeValueKey}`;

    expressionAttributeValues[attributeValueKey] = value;
    expressionAttributeNames[attributeNameKey] = key;
  });

  const params = {
    TableName: "Products",
    Key: {
      ProductId: productId
    },
    UpdateExpression: updateExpression,
    ExpressionAttributeValues: expressionAttributeValues,
    ExpressionAttributeNames: expressionAttributeNames,
    ReturnValues: "ALL_NEW" // Returns the item with the updated values
  };

  try {
    const response = await docClient.send(new UpdateCommand(params));
    console.log("Product updated:", response.Attributes);
    return response.Attributes;
  } catch (err) {
    console.error("Error updating product:", err);
    throw err;
  }
}

// Update a product
updateProduct("P003", {
  Price: 249.99,
  InStock: true,
  LastUpdated: new Date().toISOString()
});

Run the script:

node update-product.js

Deleting Items

Finally, let’s delete an item:

// delete-product.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  DeleteCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function deleteProduct(productId) {
  const params = {
    TableName: "Products",
    Key: {
      ProductId: productId
    },
    ReturnValues: "ALL_OLD" // Returns the deleted item
  };

  try {
    const response = await docClient.send(new DeleteCommand(params));
    if (response.Attributes) {
      console.log("Deleted product:", response.Attributes);
      return response.Attributes;
    } else {
      console.log("Product not found for deletion");
      return null;
    }
  } catch (err) {
    console.error("Error deleting product:", err);
    throw err;
  }
}

// Delete a product
deleteProduct("P002");

Run the script:

node delete-product.js

Section 4: Querying and Scanning Data

Familiar with these Dynamodb Challenges ?

• Writing one‑off scripts for simple DynamoDB operations
• Constantly switching between AWS profiles and regions
• Sharing and managing database operations with your team

You should try Dynomate GUI Client for DynamoDB

• Create collections of operations that work together like scripts
• Seamless integration with AWS SSO and profile switching
• Local‑first design with Git‑friendly sharing for team collaboration

Download Free TrialCompare GUI Clients

In a real application, you’ll need to retrieve multiple items based on certain criteria. DynamoDB provides two main operations for this: Query and Scan.

Understanding Query vs Scan

• Query: Retrieves items based on primary key values, very efficient
• Scan: Examines every item in a table, less efficient but more flexible

Let’s see both in action using a new table with a composite key:

// create-orders-table.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  CreateTableCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function createOrdersTable() {
  const params = {
    TableName: "Orders",
    KeySchema: [
      { AttributeName: "CustomerID", KeyType: "HASH" },  // Partition key
      { AttributeName: "OrderDate", KeyType: "RANGE" }   // Sort key
    ],
    AttributeDefinitions: [
      { AttributeName: "CustomerID", AttributeType: "S" },
      { AttributeName: "OrderDate", AttributeType: "S" }
    ],
    ProvisionedThroughput: {
      ReadCapacityUnits: 5,
      WriteCapacityUnits: 5
    }
  };

  try {
    const data = await docClient.send(new CreateTableCommand(params));
    console.log("Orders table created successfully", data);
    return data;
  } catch (err) {
    console.error("Error creating orders table:", err);
    throw err;
  }
}

createOrdersTable();

Let’s add some sample order data:

// add-orders.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  PutCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

const orders = [
  {
    CustomerID: "C001",
    OrderDate: "2025-03-15",
    OrderID: "ORD-001",
    Total: 150.25,
    Items: ["P001", "P003"],
    Status: "Delivered"
  },
  {
    CustomerID: "C001",
    OrderDate: "2025-03-20",
    OrderID: "ORD-002",
    Total: 249.99,
    Items: ["P002"],
    Status: "Processing"
  },
  {
    CustomerID: "C002",
    OrderDate: "2025-03-18",
    OrderID: "ORD-003",
    Total: 199.99,
    Items: ["P001"],
    Status: "Delivered"
  },
  {
    CustomerID: "C002",
    OrderDate: "2025-03-22",
    OrderID: "ORD-004",
    Total: 549.97,
    Items: ["P001", "P002", "P003"],
    Status: "Processing"
  },
  {
    CustomerID: "C003",
    OrderDate: "2025-03-23",
    OrderID: "ORD-005",
    Total: 299.99,
    Items: ["P003"],
    Status: "Shipped"
  }
];

async function addOrder(order) {
  const params = {
    TableName: "Orders",
    Item: order
  };

  try {
    await docClient.send(new PutCommand(params));
    console.log(`Added order: ${order.OrderID}`);
  } catch (err) {
    console.error("Error adding order:", err);
    throw err;
  }
}

async function addSampleOrders() {
  for (const order of orders) {
    await addOrder(order);
  }
}

addSampleOrders();

Using Query

Now let’s query all orders for a specific customer:

// query-orders.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  QueryCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function queryOrdersByCustomer(customerId) {
  const params = {
    TableName: "Orders",
    KeyConditionExpression: "CustomerID = :customerId",
    ExpressionAttributeValues: {
      ":customerId": customerId
    }
  };

  try {
    const response = await docClient.send(new QueryCommand(params));
    console.log(`Found ${response.Items.length} orders for customer ${customerId}:`);
    console.log(response.Items);
    return response.Items;
  } catch (err) {
    console.error("Error querying orders:", err);
    throw err;
  }
}

// Query all orders for a specific customer
queryOrdersByCustomer("C001");

We can refine our query to get orders within a specific date range:

// query-orders-date-range.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  QueryCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function queryOrdersByDateRange(customerId, startDate, endDate) {
  const params = {
    TableName: "Orders",
    KeyConditionExpression: "CustomerID = :customerId AND OrderDate BETWEEN :startDate AND :endDate",
    ExpressionAttributeValues: {
      ":customerId": customerId,
      ":startDate": startDate,
      ":endDate": endDate
    }
  };

  try {
    const response = await docClient.send(new QueryCommand(params));
    console.log(`Found ${response.Items.length} orders for customer ${customerId} between ${startDate} and ${endDate}:`);
    console.log(response.Items);
    return response.Items;
  } catch (err) {
    console.error("Error querying orders:", err);
    throw err;
  }
}

// Query orders for a customer within a date range
queryOrdersByDateRange("C002", "2025-03-01", "2025-03-20");

Using Scan with Filters

Sometimes you need to search across the entire table. Let’s scan for all processing orders:

// scan-orders.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  ScanCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function scanOrdersByStatus(status) {
  const params = {
    TableName: "Orders",
    FilterExpression: "Status = :status",
    ExpressionAttributeValues: {
      ":status": status
    }
  };

  try {
    const response = await docClient.send(new ScanCommand(params));
    console.log(`Found ${response.Items.length} orders with status ${status}:`);
    console.log(response.Items);
    return response.Items;
  } catch (err) {
    console.error("Error scanning orders:", err);
    throw err;
  }
}

// Scan for all orders with a specific status
scanOrdersByStatus("Processing");

Query vs Scan: Performance Considerations

When working with DynamoDB, it’s important to understand the performance implications:

• Query is generally more efficient as it only looks at items matching the partition key
• Scan examines every item in the table, consuming more read capacity
• For large tables, scans can be slow and expensive

Best practices:

• Design your tables and access patterns to use queries instead of scans
• If scanning is necessary, use pagination to limit the impact
• Consider using secondary indexes for common access patterns

Section 5: Working with Secondary Indexes

Sometimes your primary key doesn’t support all the access patterns you need. Secondary indexes allow you to query your data using alternative keys.

Creating a Global Secondary Index (GSI)

Let’s add a GSI to our Orders table to query by OrderID:

// add-gsi.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  UpdateTableCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function addOrderIdGSI() {
  const params = {
    TableName: "Orders",
    AttributeDefinitions: [
      { AttributeName: "OrderID", AttributeType: "S" }
    ],
    GlobalSecondaryIndexUpdates: [
      {
        Create: {
          IndexName: "OrderIDIndex",
          KeySchema: [
            { AttributeName: "OrderID", KeyType: "HASH" }
          ],
          Projection: {
            ProjectionType: "ALL"
          },
          ProvisionedThroughput: {
            ReadCapacityUnits: 5,
            WriteCapacityUnits: 5
          }
        }
      }
    ]
  };

  try {
    const response = await docClient.send(new UpdateTableCommand(params));
    console.log("Adding GSI to Orders table...");
    console.log("This may take a few minutes to complete.");
    return response;
  } catch (err) {
    console.error("Error adding GSI:", err);
    throw err;
  }
}

addOrderIdGSI();

Querying Using a GSI

Now we can query orders directly by OrderID:

// query-gsi.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  QueryCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

async function queryOrderById(orderId) {
  const params = {
    TableName: "Orders",
    IndexName: "OrderIDIndex",
    KeyConditionExpression: "OrderID = :orderId",
    ExpressionAttributeValues: {
      ":orderId": orderId
    }
  };

  try {
    const response = await docClient.send(new QueryCommand(params));
    if (response.Items.length > 0) {
      console.log("Order found:", response.Items[0]);
      return response.Items[0];
    } else {
      console.log("Order not found");
      return null;
    }
  } catch (err) {
    console.error("Error querying order by ID:", err);
    throw err;
  }
}

// Query an order by its ID
queryOrderById("ORD-003");

Understanding GSI vs LSI

DynamoDB provides two types of secondary indexes:

• Global Secondary Index (GSI):

  • Can have a different partition key than the base table
  • Can be created or deleted at any time
  • Has its own provisioned throughput
  • Eventually consistent (not strongly consistent)

• Local Secondary Index (LSI):

  • Must have the same partition key as the base table
  • Can only be created when the table is created
  • Shares provisioned throughput with the base table
  • Can support strongly consistent reads

Choose the appropriate index type based on your query needs and consistency requirements.

Section 6: Building a Simple Application

Now let’s put everything together to build a simple inventory management application. We’ll create a small Express.js API to manage our products.

First, install the required packages:

npm install express body-parser

Create an app.js file:

// app.js
import express from 'express';
import bodyParser from 'body-parser';
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  ScanCommand,
  GetCommand,
  PutCommand,
  UpdateCommand,
  DeleteCommand
} from "@aws-sdk/lib-dynamodb";
import config from './config.js';

const app = express();
const port = 3000;

// Configure middleware
app.use(bodyParser.json());

// Initialize DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);

// Define routes
app.get('/products', async (req, res) => {
  try {
    const params = {
      TableName: "Products"
    };

    const response = await docClient.send(new ScanCommand(params));
    res.json(response.Items);
  } catch (err) {
    console.error("Error fetching products:", err);
    res.status(500).json({ error: "Failed to fetch products" });
  }
});

app.get('/products/:id', async (req, res) => {
  try {
    const params = {
      TableName: "Products",
      Key: {
        ProductId: req.params.id
      }
    };

    const response = await docClient.send(new GetCommand(params));

    if (response.Item) {
      res.json(response.Item);
    } else {
      res.status(404).json({ error: "Product not found" });
    }
  } catch (err) {
    console.error("Error fetching product:", err);
    res.status(500).json({ error: "Failed to fetch product" });
  }
});

app.post('/products', async (req, res) => {
  try {
    // Validate required fields
    if (!req.body.ProductId || !req.body.Name) {
      return res.status(400).json({ error: "ProductId and Name are required" });
    }

    const product = {
      ...req.body,
      DateAdded: new Date().toISOString()
    };

    const params = {
      TableName: "Products",
      Item: product
    };

    await docClient.send(new PutCommand(params));
    res.status(201).json(product);
  } catch (err) {
    console.error("Error creating product:", err);
    res.status(500).json({ error: "Failed to create product" });
  }
});

app.put('/products/:id', async (req, res) => {
  try {
    // Check if product exists
    const getParams = {
      TableName: "Products",
      Key: {
        ProductId: req.params.id
      }
    };

    const getResponse = await docClient.send(new GetCommand(getParams));

    if (!getResponse.Item) {
      return res.status(404).json({ error: "Product not found" });
    }

    // Prepare update expression
    let updateExpression = "SET";
    const expressionAttributeValues = {};
    const expressionAttributeNames = {};

    Object.entries(req.body).forEach(([key, value], index) => {
      // Skip the primary key
      if (key === "ProductId") return;

      const attributeValueKey = `:val${index}`;
      const attributeNameKey = `#attr${index}`;

      updateExpression += updateExpression === "SET" ? ` ` : `, `;
      updateExpression += `${attributeNameKey} = ${attributeValueKey}`;

      expressionAttributeValues[attributeValueKey] = value;
      expressionAttributeNames[attributeNameKey] = key;
    });

    // Add LastUpdated timestamp
    const lastUpdatedIndex = Object.keys(expressionAttributeValues).length;
    updateExpression += updateExpression === "SET" ? ` ` : `, `;
    updateExpression += `#attrLastUpdated = :valLastUpdated`;
    expressionAttributeValues[":valLastUpdated"] = new Date().toISOString();
    expressionAttributeNames["#attrLastUpdated"] = "LastUpdated";

    const updateParams = {
      TableName: "Products",
      Key: {
        ProductId: req.params.id
      },
      UpdateExpression: updateExpression,
      ExpressionAttributeValues: expressionAttributeValues,
      ExpressionAttributeNames: expressionAttributeNames,
      ReturnValues: "ALL_NEW"
    };

    const updateResponse = await docClient.send(new UpdateCommand(updateParams));
    res.json(updateResponse.Attributes);
  } catch (err) {
    console.error("Error updating product:", err);
    res.status(500).json({ error: "Failed to update product" });
  }
});

app.delete('/products/:id', async (req, res) => {
  try {
    const params = {
      TableName: "Products",
      Key: {
        ProductId: req.params.id
      },
      ReturnValues: "ALL_OLD"
    };

    const response = await docClient.send(new DeleteCommand(params));

    if (response.Attributes) {
      res.json({ message: "Product deleted successfully", product: response.Attributes });
    } else {
      res.status(404).json({ error: "Product not found" });
    }
  } catch (err) {
    console.error("Error deleting product:", err);
    res.status(500).json({ error: "Failed to delete product" });
  }
});

// Start the server
app.listen(port, () => {
  console.log(`Server listening at http://localhost:${port}`);
});

Run the application:

node app.js

Now you can use tools like cURL, Postman, or a web browser to interact with your API:

• GET http://localhost:3000/products - List all products
• GET http://localhost:3000/products/P001 - Get a specific product
• POST http://localhost:3000/products - Create a new product
• PUT http://localhost:3000/products/P001 - Update a product
• DELETE http://localhost:3000/products/P001 - Delete a product

This simple application demonstrates how to integrate DynamoDB with a web service to create a functional backend.

Section 7: Best Practices and Optimization

To wrap up our tutorial, let’s review some DynamoDB best practices to ensure your applications are performant, cost-effective, and maintainable.

Key Design Best Practices

1. Design for your access patterns: Structure your tables and indexes based on how you’ll query the data
2. Use high-cardinality partition keys: Choose keys with many distinct values to distribute data evenly
3. Keep item sizes small: DynamoDB performance is best with smaller items (ideally under 10KB)
4. Use composite keys wisely: Leverage sort keys to organize related items within a partition

Performance Optimization

1. Choose Query over Scan: Whenever possible, use Query operations which are more efficient
2. Use projections: Only request the attributes you need to reduce data transfer
3. Implement pagination: When retrieving large result sets, use pagination to limit response size
4. Consider caching: For frequently accessed data, use DynamoDB Accelerator (DAX) or application-level caching

Cost Optimization

1. Right-size your capacity: Monitor usage and adjust provisioned capacity accordingly
2. Use auto-scaling: Let DynamoDB automatically adjust capacity based on traffic patterns
3. Consider on-demand pricing: For unpredictable workloads, on-demand might be more cost-effective
4. Use TTL for temporary data: Automatically expire and remove data you no longer need

Error Handling

1. Implement retry logic: Use exponential backoff for throttled requests
2. Handle conditional check failures: When using conditional writes, handle these exceptions gracefully
3. Monitor and alert: Set up CloudWatch alarms for throttling events and high consumption

Advanced Patterns

1. Single-table design: For complex applications, consider using a single table for multiple entity types
2. Sparse indexes: Create indexes that include only a subset of items to save costs
3. Overloading keys: Use prefixes in key values to differentiate between entity types
4. Write sharding: For high-throughput writes to a single partition key, implement write sharding

Conclusion

Switching from Dynobase? Try Dynomate

Developers are switching to Dynomate for these key advantages:

Better Multi-Profile Support

• Native AWS SSO integration
• Seamless profile switching
• Multiple accounts in a single view

Developer-Focused Workflow

• Script-like operation collections
• Chain data between operations
• Full AWS API logging for debugging

Team Collaboration

• Git-friendly collection sharing
• No account required for installation
• Local-first data storage for privacy

Privacy & Security

• No account creation required
• 100% local data storage
• No telemetry or usage tracking

Try Dynomate Free for 7 DaysDynomate vs. Dynobase

Congratulations! You’ve completed our DynamoDB tutorial for beginners. You’ve learned how to:

• Set up DynamoDB and create tables
• Perform basic CRUD operations
• Query and scan data efficiently
• Work with secondary indexes
• Build a simple application
• Apply best practices for performance and cost optimization

DynamoDB’s flexibility, scalability, and managed nature make it an excellent choice for modern applications. By understanding its key concepts and following best practices, you can build robust, scalable systems that can handle virtually any workload.

Next Steps

To continue your DynamoDB journey:

1. Explore more advanced concepts like DynamoDB Streams for event-driven architectures
2. Learn about DynamoDB’s integration with AWS Lambda for serverless applications
3. Understand DynamoDB’s GSI vs LSI in more depth
4. Dive into single-table design for complex data modeling

For easier management and development with DynamoDB, check out Dynomate - our intuitive tool designed to visualize, query, and manage your DynamoDB tables with minimal effort.

Do you have questions about this tutorial or DynamoDB in general? Let us know in the comments below!