Dynomate

DynamoDB Tutorial: A Hands-On Guide for Beginners

Build a DynamoDB table from scratch in Node.js: keys, CRUD, Query versus Scan, and a GSI. Runs locally or on the free tier, with no prior NoSQL experience.

Orlando Adeyemi 18 min read
On this page11
  1. 1Introduction
  2. 2What You’ll Learn
  3. 3Prerequisites
  4. 4Section 1: Getting Started with DynamoDB
  5. 5Section 2: Creating Your First DynamoDB Table
  6. 6Section 3: Basic CRUD Operations
  7. 7Section 4: Querying and Scanning Data
  8. 8Section 5: Working with Secondary Indexes
  9. 9Section 6: Building a Simple Application
  10. 10Section 7: Best Practices and Optimization
  11. 11Conclusion

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)

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

  1. Download the DynamoDB local JAR file
  2. Start the local instance:
Shell 
# Create a directory for DynamoDB datamkdir dynamodb-local-data# Start DynamoDB local with the directory as storagejava -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. To browse it in a GUI, connect Dynomate to DynamoDB Local.

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:
Shell 
mkdir dynamodb-tutorialcd dynamodb-tutorialnpm init -y
  1. Install the AWS SDK for JavaScript v3:
Shell 
npm install @aws-sdk/client-dynamodb @aws-sdk/lib-dynamodb
  1. Create a file named config.js with your AWS configuration:
JavaScript 
// config.jsconst 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

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:

JavaScript 
// create-table.jsimport { 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:

Shell 
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:

JavaScript 
// add-products.jsimport { 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 productsconst 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:

Shell 
node add-products.js

Reading Items from Your Table

Now let’s retrieve data from our table:

JavaScript 
// read-product.jsimport { 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 IDgetProduct("P001");

Run the script:

Shell 
node read-product.js

Updating Items

Let’s update an existing product:

JavaScript 
// update-product.jsimport { 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 productupdateProduct("P003", {  Price: 249.99,  InStock: true,  LastUpdated: new Date().toISOString()});

Run the script:

Shell 
node update-product.js

Deleting Items

Finally, let’s delete an item:

JavaScript 
// delete-product.jsimport { 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 productdeleteProduct("P002");

Run the script:

Shell 
node delete-product.js

Section 4: Querying and Scanning Data

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

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

JavaScript 
// create-orders-table.jsimport { 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:

JavaScript 
// add-orders.jsimport { 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:

JavaScript 
// query-orders.jsimport { 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 customerqueryOrdersByCustomer("C001");

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

JavaScript 
// query-orders-date-range.jsimport { 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 rangequeryOrdersByDateRange("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:

JavaScript 
// scan-orders.jsimport { 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 statusscanOrdersByStatus("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:

JavaScript 
// add-gsi.jsimport { 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:

JavaScript 
// query-gsi.jsimport { 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 IDqueryOrderById("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:

Shell 
npm install express body-parser

Create an app.js file:

JavaScript 
// app.jsimport 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 middlewareapp.use(bodyParser.json());// Initialize DynamoDB clientconst client = new DynamoDBClient(config);const docClient = DynamoDBDocumentClient.from(client);// Define routesapp.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 serverapp.listen(port, () => {  console.log(`Server listening at http://localhost:${port}`);});

Run the application:

Shell 
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

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!

Related articles

All posts

Run DynamoDB Locally with Docker or the JAR

Get DynamoDB Local running with one docker command, keep data across restarts, and connect from the CLI, Boto3, Node or Java. Plus what Local cannot do.

Reading time: 8 min

10 DynamoDB Advantages and 10 Disadvantages

DynamoDB scales to millions of requests with no DBA, but the 400KB item cap and rigid access patterns bite. Ten upsides, ten tradeoffs, and when to walk.

Reading time: 12 min

DynamoDB Data Types: Every Type, With Examples

The scalar, document, set and binary types DynamoDB supports, how each counts against the 400KB item limit, and the empty-value rules that break writes.

Reading time: 10 min