Why DynamoDB pairs with Lambda - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is DynamoDB a good match for AWS Lambda?

Which reason best explains why DynamoDB works well with AWS Lambda?

A Lambda functions can only read data from DynamoDB but cannot write back to it.

B DynamoDB stores data in files that Lambda reads directly from the file system.

C DynamoDB requires manual polling by Lambda to detect data changes, which is efficient.

D DynamoDB automatically triggers Lambda functions on data changes, enabling event-driven processing.

💡 Hint

Think about how Lambda can react to changes in DynamoDB data automatically.

DynamoDB Streams can trigger Lambda functions automatically when data changes, making it easy to build event-driven applications.

🧠 Conceptual

intermediate

What benefit does Lambda provide when paired with DynamoDB?

What is a key benefit of using Lambda with DynamoDB for backend logic?

A Lambda lets you run backend code without managing servers, triggered by DynamoDB events.

B Lambda requires you to manage servers to process DynamoDB data.

C Lambda only works with relational databases, not DynamoDB.

D Lambda stores data permanently, replacing DynamoDB's role.

💡 Hint

Consider how Lambda helps run code without worrying about servers.

Lambda is serverless, so it runs your code in response to DynamoDB events without you managing any servers.

❓ query_result

advanced

What output does this DynamoDB Stream event Lambda receive?

Given a DynamoDB table with an item inserted, what does the Lambda event contain?

DynamoDB

Event example: { "Records": [ { "eventName": "INSERT", "dynamodb": { "NewImage": { "id": { "S": "123" }, "name": { "S": "Alice" } } } } ] }

A The event is empty because inserts do not trigger Lambda.

B The event contains only the old item data before insertion.

C The event contains the new item data under Records[0].dynamodb.NewImage.

D The event contains a SQL query string to fetch the new item.

💡 Hint

Think about what data DynamoDB Streams send on an insert.

On an insert, DynamoDB Streams send the new item data in NewImage, which Lambda receives in the event.

❓ optimization

advanced

How to optimize Lambda processing with DynamoDB Streams?

Which approach best optimizes Lambda function performance when processing DynamoDB Streams?

A Disable DynamoDB Streams to avoid Lambda triggers and improve speed.

B Batch multiple stream records in one Lambda invocation to reduce overhead.

C Invoke a separate Lambda for each individual stream record immediately.

D Use Lambda to poll DynamoDB table every second instead of streams.

💡 Hint

Think about reducing the number of Lambda invocations for efficiency.

Batching multiple stream records in one Lambda invocation reduces cold starts and overhead, improving performance.

🔧 Debug

expert

Why does this Lambda fail to process DynamoDB Stream events?

Given this Lambda code snippet processing DynamoDB Stream events, why does it fail?

exports.handler = async (event) => {
  const record = event.Records[0];
  const id = record.dynamodb.NewImage.id;
  console.log('ID:', id);
};

A Because NewImage attributes are objects with type keys, you must access id.S to get the string value.

B Because event.Records is empty on insert events, so record is undefined.

C Because Lambda cannot access DynamoDB Stream events without special permissions.

D Because console.log is not supported in Lambda functions.

💡 Hint

Remember how DynamoDB represents attribute values in streams.

DynamoDB Stream records represent attribute values as objects with type keys like S for string, so you must use id.S to get the actual value.

Practice

1. Why is DynamoDB often paired with AWS Lambda in serverless applications?

easy

A. Because Lambda can automatically run code when DynamoDB data changes

B. Because DynamoDB requires Lambda to store data

C. Because Lambda stores data faster than DynamoDB

D. Because DynamoDB and Lambda are both relational databases

Solution

1. Step 1: Understand DynamoDB's role

   DynamoDB stores data quickly and scales automatically without needing servers.

2. Step 2: Understand Lambda's role

   Lambda runs code automatically in response to events, such as changes in DynamoDB data.

3. Final Answer:

   Because Lambda can automatically run code when DynamoDB data changes -> Option A

4. Quick Check:

   Event-driven code execution = C [OK]

Hint: Remember: Lambda reacts to DynamoDB events automatically [OK]

Common Mistakes:

• Thinking DynamoDB needs Lambda to store data
• Confusing Lambda as a database
• Believing both are relational databases

2. Which of the following is the correct way to configure a Lambda function to trigger on DynamoDB table changes?

easy

A. Directly call Lambda from DynamoDB without any configuration

B. Set up a DynamoDB Stream and attach it as an event source to the Lambda function

C. Use Lambda to poll the DynamoDB table every second

D. Configure DynamoDB to run Lambda code inside its console

Solution

1. Step 1: Identify how DynamoDB triggers Lambda

   DynamoDB Streams capture table changes and can be linked to Lambda as event sources.

2. Step 2: Evaluate options

   Only setting up a DynamoDB Stream and attaching it to Lambda is correct; others are invalid or impossible.

3. Final Answer:

   Set up a DynamoDB Stream and attach it as an event source to the Lambda function -> Option B

4. Quick Check:

   DynamoDB Stream triggers Lambda = A [OK]

Hint: Use DynamoDB Streams to trigger Lambda functions [OK]

Common Mistakes:

• Assuming Lambda can be called directly by DynamoDB without streams
• Thinking Lambda polls DynamoDB instead of event-driven
• Believing DynamoDB runs Lambda code internally

3. Given this Lambda function triggered by a DynamoDB Stream event, what will be the output if a new item with {"id": "123", "status": "new"} is inserted?

exports.handler = async (event) => {
  for (const record of event.Records) {
    if (record.eventName === 'INSERT') {
      console.log('New item:', record.dynamodb.NewImage);
    }
  }
};

medium

A. Throws an error because NewImage is undefined

B. Does nothing because INSERT events are ignored

C. Logs only the id value as a string

D. Logs the new item data with keys and DynamoDB types

Solution

1. Step 1: Understand DynamoDB Stream event structure

   INSERT events include NewImage with the new item's attributes and their DynamoDB types.

2. Step 2: Analyze the Lambda code

   The code logs the NewImage object for INSERT events, so it outputs the full item with types.

3. Final Answer:

   Logs the new item data with keys and DynamoDB types -> Option D

4. Quick Check:

   INSERT event logs NewImage = B [OK]

Hint: INSERT events include NewImage with full item data [OK]

Common Mistakes:

• Assuming NewImage is undefined for INSERT
• Expecting only raw values without DynamoDB types
• Thinking INSERT events are ignored

4. A developer wrote this Lambda function to process DynamoDB Stream events but it never triggers. What is the likely issue?

exports.handler = async (event) => {
  console.log('Event received');
};

Options:

medium

A. The DynamoDB Stream is not enabled or not attached as an event source

B. The Lambda function code is missing a return statement

C. The function should use synchronous invocation instead of async

D. The console.log statement prevents the function from running

Solution

1. Step 1: Check event source configuration

   Lambda triggers on DynamoDB Streams only if the stream is enabled and linked as an event source.

2. Step 2: Evaluate code and invocation

   Code with async and console.log is valid; missing return or sync invocation does not stop triggering.

3. Final Answer:

   The DynamoDB Stream is not enabled or not attached as an event source -> Option A

4. Quick Check:

   Missing stream or event source = D [OK]

Hint: Check if DynamoDB Stream is enabled and linked to Lambda [OK]

Common Mistakes:

• Thinking async keyword blocks Lambda triggers
• Believing console.log stops execution
• Assuming return statement is required for triggers

5. You want to build a serverless app that updates a search index whenever DynamoDB data changes. Which approach best uses DynamoDB and Lambda together?

hard

A. Write search index updates directly inside DynamoDB using Lambda code embedded in the table

B. Have Lambda poll DynamoDB every minute to check for changes and update the index

C. Enable DynamoDB Streams, trigger Lambda on changes, and update the search index inside Lambda

D. Use DynamoDB triggers to run the search index update without Lambda

Solution

1. Step 1: Identify event-driven update method

   Using DynamoDB Streams to trigger Lambda on data changes is efficient and real-time.

2. Step 2: Evaluate alternatives

   Polling wastes resources, embedding code in DynamoDB is not possible, and DynamoDB triggers require Lambda.

3. Final Answer:

   Enable DynamoDB Streams, trigger Lambda on changes, and update the search index inside Lambda -> Option C

4. Quick Check:

   Event-driven updates with Streams + Lambda = A [OK]

Hint: Use Streams + Lambda for real-time updates, avoid polling [OK]

Common Mistakes:

• Choosing polling instead of event triggers
• Thinking DynamoDB can run code internally
• Ignoring the need for Lambda in triggers