DynamoDB for Developers

Amazon DynamoDB is a fully managed NoSQL database service that provides single-digit millisecond latency at any scale. It is a key-value and document database that supports both structured and semi-structured data (JSON, documents). It is serverless — no servers to provision, patch, or manage — and scales automatically to handle throughput and storage. DynamoDB is designed for high-traffic web applications, gaming, IoT, ad tech, and any workload requiring consistent performance at scale.

Traditional relational databases (RDBMS) like Amazon RDS enforce schemas, support complex joins, and provide ACID transactions. However, they struggle with horizontal scaling and can introduce latency under heavy read/write loads. DynamoDB sacrifices some relational features (joins, complex queries) to achieve predictable performance, automatic scaling, and high availability. It is optimized for access patterns where you know your primary key and need fast, consistent lookups.

DynamoDB stores data across multiple partitions automatically. Each partition is a unit of storage and compute. When you create a table, DynamoDB initially creates enough partitions to handle the provisioned capacity. Data is distributed across partitions based on the partition key's hash value. The hash function ensures uniform distribution, but if you choose a poor partition key (e.g., a date that grows monotonically), you can create hot partitions.

#### Tables, Items, and Attributes - Table: A collection of items, analogous to a table in RDBMS. - Item: A single record in a table, analogous to a row. Each item is uniquely identified by the primary key. - Attribute: A data element within an item, analogous to a column. Attributes can be of various types: scalar (string, number, binary, boolean, null), document (list, map), or set (string set, number set, binary set).

#### Primary Key Every table must have a primary key. Two options: - Partition key only (simple primary key): A single attribute that uniquely identifies each item. Example: UserId (String). - Partition key and sort key (composite primary key): Two attributes that together form the unique identifier. Example: UserId (partition key) and Timestamp (sort key). Items with the same partition key are stored together, sorted by sort key.

#### Secondary Indexes DynamoDB supports two types of secondary indexes to enable querying on non-key attributes: - Global Secondary Index (GSI): An index with a different partition key and sort key than the table. It spans all partitions. You can create up to 20 GSIs per table (default limit, can be increased). GSIs have their own provisioned read/write capacity settings. - Local Secondary Index (LSI): An index that uses the same partition key as the table but a different sort key. It is local to a partition. You can create up to 5 LSIs per table, and they must be defined at table creation time (cannot be added later). LSIs share the table's provisioned capacity.

#### Read/Write Capacity Modes DynamoDB offers two capacity modes: - Provisioned Capacity: You specify the number of reads and writes per second. You can set Read Capacity Units (RCUs) and Write Capacity Units (WCUs). One RCU = one strongly consistent read per second for an item up to 4 KB, or two eventually consistent reads per second. One WCU = one write per second for an item up to 1 KB. You can use Auto Scaling to adjust capacity automatically based on utilization. - On-Demand Capacity: You pay per request (reads and writes). DynamoDB scales instantly to handle any traffic. Suitable for unpredictable workloads. On-demand is more expensive per request than provisioned but eliminates capacity planning.

#### Consistency Models DynamoDB offers two consistency models for reads: - Eventually Consistent Reads (default): The read may not reflect the most recent write. Consistency is usually achieved within one second. This option uses half the RCUs of strongly consistent reads. - Strongly Consistent Reads: Returns the most up-to-date data. However, it may have higher latency and is not supported in some scenarios (e.g., GSIs are eventually consistent only).

#### DynamoDB Streams DynamoDB Streams captures a time-ordered sequence of item-level changes (inserts, updates, deletes) in a table. Stream records are written in near real-time and can be read by AWS Lambda, Kinesis, or custom consumers. Streams are useful for cross-region replication, materialized views, and event-driven architectures. You can enable streams on a table with four view types: KEYS_ONLY, NEW_IMAGE, OLD_IMAGE, and NEW_AND_OLD_IMAGES.

#### Transactions DynamoDB Transactions provide ACID guarantees across one or more tables within a single AWS account and region. You can use the TransactGetItems and TransactWriteItems APIs. Transactions consume 2x the RCUs/WCUs of standard operations. They are useful for financial transactions, inventory management, and other scenarios requiring atomicity.

#### Time to Live (TTL) TTL allows you to define a per-item timestamp attribute to automatically delete items after a specified expiry. This helps manage storage costs and comply with data retention policies. TTL is best-effort — expired items are typically deleted within 48 hours.

#### DynamoDB Accelerator (DAX) DAX is an in-memory cache for DynamoDB that delivers up to 10x read performance improvement. It is fully managed, compatible with existing DynamoDB APIs, and sits between your application and the database. DAX is ideal for read-heavy workloads with frequent access to the same items (e.g., gaming leaderboards, product catalogs).

Using AWS CLI:

Create a table:

aws dynamodb create-table \
    --table-name Users \
    --attribute-definitions AttributeName=UserId,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH \
    --billing-mode PROVISIONED \
    --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5

Put an item:

aws dynamodb put-item \
    --table-name Users \
    --item '{"UserId": {"S": "user123"}, "Name": {"S": "Alice"}}'

Query with GSI:

aws dynamodb query \
    --table-name Users \
    --index-name NameIndex \
    --key-condition-expression "Name = :name" \
    --expression-attribute-values '{ ":name": {"S": "Alice"} }'

For the DVA-C02, you must know: