Identifying access patterns first in DynamoDB - Mini Project: Build & Apply

Identifying Access Patterns First

📖 Scenario: You are designing a DynamoDB table for a simple online bookstore. You want to store book information and be able to quickly find books by their ISBN or by the author's name.

🎯 Goal: Create a DynamoDB table structure that supports fast lookups by ISBN and by author name. You will define the main table and a secondary index to support these access patterns.

📋 What You'll Learn

Create a DynamoDB table named Books with ISBN as the partition key.

Add a Global Secondary Index (GSI) named AuthorIndex with Author as the partition key.

Include attributes Title and Author in the table items.

💡 Why This Matters

🌍 Real World

Designing DynamoDB tables by identifying access patterns first helps build fast and scalable applications like online bookstores, social media apps, or inventory systems.

💼 Career

Understanding how to model DynamoDB tables and indexes based on access patterns is a key skill for cloud developers, backend engineers, and database architects working with AWS.

1

Create the DynamoDB table structure

Create a DynamoDB table named Books with ISBN as the partition key. Define the attributes ISBN, Title, and Author in the item structure.

DynamoDB

# Define the Books table with ISBN as the partition key
# Your code here

Hint

Remember to set ISBN as the partition key in KeySchema and define it in AttributeDefinitions.

2

Add a Global Secondary Index for author lookups

Add a Global Secondary Index named AuthorIndex to the Books table. Use Author as the partition key for this index.

DynamoDB

Books = {
    'TableName': 'Books',
    'KeySchema': [
        {'AttributeName': 'ISBN', 'KeyType': 'HASH'}
    ],
    'AttributeDefinitions': [
        {'AttributeName': 'ISBN', 'AttributeType': 'S'},
        {'AttributeName': 'Author', 'AttributeType': 'S'}
    ],
    'ProvisionedThroughput': {
        'ReadCapacityUnits': 5,
        'WriteCapacityUnits': 5
    },
    # Add Global Secondary Index here
    # Your code here
}

Hint

Use GlobalSecondaryIndexes with IndexName set to AuthorIndex and Author as the partition key.

3

Add sample book items

Create a list named book_items with two dictionaries representing books. Each dictionary should have keys ISBN, Title, and Author with these exact values: first book with ISBN 978-0132350884, Title Clean Code, Author Robert C. Martin; second book with ISBN 978-0201616224, Title The Pragmatic Programmer, Author Andrew Hunt.

DynamoDB

Books = {
    'TableName': 'Books',
    'KeySchema': [
        {'AttributeName': 'ISBN', 'KeyType': 'HASH'}
    ],
    'AttributeDefinitions': [
        {'AttributeName': 'ISBN', 'AttributeType': 'S'},
        {'AttributeName': 'Author', 'AttributeType': 'S'}
    ],
    'ProvisionedThroughput': {
        'ReadCapacityUnits': 5,
        'WriteCapacityUnits': 5
    },
    'GlobalSecondaryIndexes': [
        {
            'IndexName': 'AuthorIndex',
            'KeySchema': [
                {'AttributeName': 'Author', 'KeyType': 'HASH'}
            ],
            'Projection': {
                'ProjectionType': 'ALL'
            },
            'ProvisionedThroughput': {
                'ReadCapacityUnits': 5,
                'WriteCapacityUnits': 5
            }
        }
    ]
}

# Create a list named book_items with two book dictionaries
# Your code here

Hint

Make sure the list is named book_items and contains exactly two dictionaries with the specified keys and values.

4

Define the final table creation parameters

Add the Item key to the book_items dictionaries to prepare them for insertion. Then, create a list named put_requests where each element is a dictionary with the key PutRequest and the value is a dictionary with the key Item set to the book item. This structure is used for batch writing items to DynamoDB.

DynamoDB

Books = {
    'TableName': 'Books',
    'KeySchema': [
        {'AttributeName': 'ISBN', 'KeyType': 'HASH'}
    ],
    'AttributeDefinitions': [
        {'AttributeName': 'ISBN', 'AttributeType': 'S'},
        {'AttributeName': 'Author', 'AttributeType': 'S'}
    ],
    'ProvisionedThroughput': {
        'ReadCapacityUnits': 5,
        'WriteCapacityUnits': 5
    },
    'GlobalSecondaryIndexes': [
        {
            'IndexName': 'AuthorIndex',
            'KeySchema': [
                {'AttributeName': 'Author', 'KeyType': 'HASH'}
            ],
            'Projection': {
                'ProjectionType': 'ALL'
            },
            'ProvisionedThroughput': {
                'ReadCapacityUnits': 5,
                'WriteCapacityUnits': 5
            }
        }
    ]
}

book_items = [
    {'ISBN': '978-0132350884', 'Title': 'Clean Code', 'Author': 'Robert C. Martin'},
    {'ISBN': '978-0201616224', 'Title': 'The Pragmatic Programmer', 'Author': 'Andrew Hunt'}
]

# Create put_requests list for batch write
# Your code here

Hint

Use a list comprehension to create put_requests with each element as a dictionary containing PutRequest and Item.

Practice

1. Why is it important to identify access patterns before designing a DynamoDB table?

easy

A. Because it tells how many users will use the app.

B. Because it helps to choose the right programming language for the app.

C. Because access patterns determine the keys and indexes needed for efficient queries.

D. Because it decides the color scheme of the app interface.

Solution

1. Step 1: Understand the role of access patterns

   Access patterns describe how the app will retrieve data, which guides table design.

2. Step 2: Connect access patterns to keys and indexes

   Keys and indexes in DynamoDB are chosen based on these patterns to make queries fast and efficient.

3. Final Answer:

   Because access patterns determine the keys and indexes needed for efficient queries. -> Option C

4. Quick Check:

   Access patterns = keys/indexes choice [OK]

Hint: Access patterns guide key/index design for fast queries [OK]

Common Mistakes:

• Thinking access patterns affect UI design
• Confusing access patterns with user count
• Believing access patterns decide programming language

2. Which of the following is the correct way to describe an access pattern in DynamoDB?

easy

A. A list of all table columns.

B. A query that the app will run to get data.

C. The number of items in the table.

D. The size of the database backup.

Solution

1. Step 1: Define what an access pattern is

   An access pattern is a way the app queries or retrieves data from the database.

2. Step 2: Match the options to this definition

   Only "A query that the app will run to get data." describes a query the app will run, which fits the access pattern meaning.

3. Final Answer:

   A query that the app will run to get data. -> Option B

4. Quick Check:

   Access pattern = app query [OK]

Hint: Access pattern means how app queries data [OK]

Common Mistakes:

• Confusing access pattern with table schema
• Thinking access pattern is about data size
• Mixing access pattern with backup info

3. Given an app needs to get user orders by user ID and order date, which access pattern should be planned first?

medium

A. Query orders by user ID and sort by order date.

B. Scan all orders and filter by user ID.

C. Get orders by order date only.

D. Query orders by product ID.

Solution

1. Step 1: Identify the required data retrieval

   The app needs orders filtered by user ID and sorted by order date.

2. Step 2: Choose the access pattern matching this need

   Querying by user ID and sorting by order date matches the requirement and is efficient.

3. Final Answer:

   Query orders by user ID and sort by order date. -> Option A

4. Quick Check:

   Access pattern = query by user ID + order date [OK]

Hint: Match access pattern to app's data retrieval need [OK]

Common Mistakes:

• Using scan instead of query causes slow performance
• Ignoring sorting by order date
• Querying by unrelated keys like product ID

4. You designed a DynamoDB table without identifying access patterns first. Your app queries are slow. What is the likely cause?

medium

A. The table keys and indexes do not support the app's query needs.

B. The app has too many users.

C. The table has too many columns.

D. The app is using the wrong programming language.

Solution

1. Step 1: Understand the impact of missing access pattern planning

   Without access patterns, keys and indexes may not match query needs, causing slow queries.

2. Step 2: Eliminate unrelated causes

   User count, column number, or programming language do not directly cause slow DynamoDB queries.

3. Final Answer:

   The table keys and indexes do not support the app's query needs. -> Option A

4. Quick Check:

   Missing access patterns = wrong keys/indexes = slow queries [OK]

Hint: Slow queries often mean keys/indexes mismatch access patterns [OK]

Common Mistakes:

• Blaming app user count for query speed
• Thinking table columns affect query speed directly
• Assuming programming language affects DynamoDB speed

5. An app needs to retrieve customer profiles by email and also list all customers in a city. How should you identify access patterns to design the DynamoDB table?

hard

A. Store all customers in one table without keys and scan for queries.

B. Create separate tables for email and city queries.

C. Use email as the only key and ignore city queries.

D. Plan one access pattern to query by email and another to query by city using a secondary index.

Solution

1. Step 1: Identify the two access patterns

   The app needs to get customers by email and also list customers by city.

2. Step 2: Design keys and indexes accordingly

   Use email as the primary key and create a secondary index on city to support both queries efficiently.

3. Final Answer:

   Plan one access pattern to query by email and another to query by city using a secondary index. -> Option D

4. Quick Check:

   Multiple access patterns = primary key + secondary index [OK]

Hint: Use secondary indexes for multiple access patterns [OK]

Common Mistakes:

• Ignoring secondary indexes for city queries
• Using scans instead of queries
• Creating separate tables unnecessarily