Stream processing patterns in DynamoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Identify the correct DynamoDB Stream event type for a new item insertion

When a new item is added to a DynamoDB table with streams enabled, which event type will appear in the stream record?

A MODIFY

B INSERT

C REMOVE

D UPDATE

💡 Hint

Think about what event type corresponds to adding new data.

The INSERT event type is generated when a new item is added to the table. MODIFY is for updates, REMOVE is for deletions, and UPDATE is not a valid DynamoDB stream event type.

🧠 Conceptual

intermediate

Understanding the purpose of DynamoDB Streams in event-driven architectures

Why are DynamoDB Streams commonly used in event-driven architectures?

A To capture and react to data changes in real-time for downstream processing

B To store backups of the entire DynamoDB table periodically

C To improve query performance by caching data

D To encrypt data at rest automatically

💡 Hint

Think about what streams provide besides just storing data.

DynamoDB Streams capture data modification events in real-time, enabling other services to react to changes immediately. They are not used for backups, caching, or encryption.

📝 Syntax

advanced

Identify the correct AWS Lambda event source mapping filter for DynamoDB Streams

Which JSON filter pattern correctly filters DynamoDB Stream events to only process INSERT events in an AWS Lambda event source mapping?

A {"eventName": ["INSERT"]}

B {"eventName": "INSERT"}

C {"Records": [{"eventName": "INSERT"}]}

D {"eventName": {"equals": "INSERT"}}

💡 Hint

AWS Lambda event source filters expect arrays for matching values.

The correct filter pattern uses an array for the eventName key to match INSERT events. Option A is invalid because it uses a string instead of an array. Option A is incorrect because the filter does not include the Records wrapper. Option A uses an invalid syntax.

❓ optimization

advanced

Optimize processing of high-volume DynamoDB Streams to avoid Lambda throttling

You have a DynamoDB table with a high write rate generating many stream records. Which approach best helps avoid AWS Lambda throttling when processing these streams?

A Increase the number of shards by splitting the table into multiple partitions

B Set the Lambda batch size to 1 and increase the number of concurrent Lambda executions

C Use DynamoDB Streams with enhanced fan-out to allow multiple consumers to process records independently

D Disable DynamoDB Streams and poll the table directly for changes

💡 Hint

Consider how to scale stream consumers efficiently.

Enhanced fan-out allows multiple Lambda functions or consumers to receive stream records with dedicated throughput, reducing throttling. Increasing shards by splitting the table is not directly possible. Setting batch size to 1 may increase overhead. Disabling streams removes the event-driven benefit.

🔧 Debug

expert

Diagnose why a Lambda function triggered by DynamoDB Streams processes duplicate records

A Lambda function triggered by DynamoDB Streams sometimes processes the same record multiple times. What is the most likely cause?

A The Lambda function is configured with an incorrect IAM role

B DynamoDB Streams duplicates records by design to ensure delivery

C The table's stream view type is set to KEYS_ONLY instead of NEW_IMAGE

D The Lambda function does not checkpoint processed records, causing retries on failure

💡 Hint

Think about how Lambda handles stream record processing and retries.

Lambda retries processing records if the function does not successfully checkpoint or acknowledge them, leading to duplicates. DynamoDB Streams does not duplicate records arbitrarily. Stream view type affects data content, not duplication. IAM role issues cause permission errors, not duplicates.

Practice

1. What is the main purpose of using DynamoDB Streams in stream processing patterns?

easy

A. To capture and react to data changes in real time

B. To store large amounts of data permanently

C. To create backups of the database

D. To improve query speed by indexing

Solution

1. Step 1: Understand DynamoDB Streams role

   DynamoDB Streams capture data changes like inserts, updates, and deletes as they happen.

2. Step 2: Identify the purpose in stream processing

   Streams allow applications to react immediately to these changes, enabling real-time processing.

3. Final Answer:

   To capture and react to data changes in real time -> Option A

4. Quick Check:

   Streams = real-time data reaction [OK]

Hint: Streams track changes instantly for real-time reactions [OK]

Common Mistakes:

• Confusing Streams with data storage
• Thinking Streams create backups
• Assuming Streams speed up queries

2. Which of the following is the correct way to enable a DynamoDB Stream on a table?

easy

A. Create a global secondary index with Streams enabled

B. Add a Lambda trigger without enabling Streams

C. Set StreamSpecification with StreamEnabled = true and StreamViewType

D. Use the UpdateItem API to activate Streams

Solution

1. Step 1: Recall how to enable Streams

   Streams are enabled by setting the StreamSpecification property on the table with StreamEnabled set to true and choosing a StreamViewType.

2. Step 2: Evaluate options

   Set StreamSpecification with StreamEnabled = true and StreamViewType correctly describes enabling Streams. The other options do not enable Streams properly.

3. Final Answer:

   Set StreamSpecification with StreamEnabled = true and StreamViewType -> Option C

4. Quick Check:

   Enable Streams via StreamSpecification [OK]

Hint: Enable Streams in table settings, not via Lambda or indexes [OK]

Common Mistakes:

• Trying to enable Streams via Lambda triggers
• Confusing Streams with indexes
• Using UpdateItem API to enable Streams

3. Given a DynamoDB Stream enabled with NEW_IMAGE view type, what will a Lambda function receive when an item is updated?

medium

A. Only the old item image before the update

B. Only the new item image after the update

C. Both old and new item images

D. No item images, only keys

Solution

1. Step 1: Understand StreamViewType NEW_IMAGE

   NEW_IMAGE means the stream records contain the item as it appears after the change.

2. Step 2: Determine what Lambda receives on update

   Lambda gets the new item image only, not the old one or both.

3. Final Answer:

   Only the new item image after the update -> Option B

4. Quick Check:

   NEW_IMAGE = new item data only [OK]

Hint: NEW_IMAGE streams send updated item data only [OK]

Common Mistakes:

• Confusing NEW_IMAGE with OLD_IMAGE or BOTH_IMAGES
• Expecting both old and new images
• Assuming keys only are sent

4. A developer wrote a Lambda function triggered by DynamoDB Streams but it never processes any records. What is the most likely cause?

medium

A. The DynamoDB table does not have Streams enabled

B. The Lambda function code has a syntax error

C. The table has no data at all

D. The Lambda function timeout is too long

Solution

1. Step 1: Check Stream enablement

   If Streams are not enabled on the table, no events trigger Lambda.

2. Step 2: Evaluate other options

   Syntax errors cause failures but do not prevent invocation. No data means no changes, but usually there are some. Timeout too long does not stop invocation.

3. Final Answer:

   The DynamoDB table does not have Streams enabled -> Option A

4. Quick Check:

   Streams must be enabled for Lambda triggers [OK]

Hint: Check if Streams are enabled before debugging Lambda code [OK]

Common Mistakes:

• Assuming code errors stop Lambda from triggering
• Ignoring Streams enablement
• Thinking timeout affects event triggering

5. You want to build a system that sends notifications only when a specific attribute "status" changes in DynamoDB items. Which stream processing pattern best fits this requirement?

hard

A. Use Streams with OLD_IMAGE view type only

B. Disable Streams and poll the table periodically

C. Enable Streams with KEYS_ONLY view type and check keys in Lambda

D. Filter and transform stream records in Lambda to detect "status" changes

Solution

1. Step 1: Understand the need to detect attribute changes

   To detect changes in "status", you need both old and new values to compare.

2. Step 2: Choose the right pattern

   Filtering and transforming stream records in Lambda lets you compare old and new images and trigger notifications only on "status" changes.

3. Step 3: Evaluate other options

   OLD_IMAGE alone lacks new data, KEYS_ONLY lacks attribute data, polling is inefficient and not real-time.

4. Final Answer:

   Filter and transform stream records in Lambda to detect "status" changes -> Option D

5. Quick Check:

   Filter stream records in Lambda for attribute changes [OK]

Hint: Compare old and new images in Lambda to detect attribute changes [OK]

Common Mistakes:

• Using KEYS_ONLY which lacks attribute data
• Relying on OLD_IMAGE without new data
• Polling instead of using Streams