Why DynamoDB pairs with Lambda - The Real Reasons

The Big Idea

Discover how two simple tools can make your app smarter and faster without extra work!

The Scenario

Imagine you have a busy online store and you want to update inventory every time someone buys something. Doing this by hand means checking stock, updating numbers, and making sure nothing breaks -- all while customers keep shopping.

The Problem

Manually updating inventory is slow and mistakes happen easily. If two people buy the same item at once, you might sell more than you have. Plus, constantly watching and updating data wastes time and can cause errors.

The Solution

DynamoDB and Lambda work together like a smart team. When a change happens in DynamoDB, Lambda automatically runs code to update or react instantly. This means no waiting, no mistakes, and everything stays in sync without you lifting a finger.

Before vs After

✗ Before

Check stock in database;
Update stock manually;
Notify system;

✓ After

On DynamoDB change trigger:
  Run Lambda function to update stock automatically;

What It Enables

This pairing lets your app react instantly to data changes, making it fast, reliable, and hands-free.

Real Life Example

When a customer places an order, DynamoDB records it and Lambda immediately updates inventory and sends a confirmation email without delay.

Key Takeaways

Manual updates are slow and error-prone.

DynamoDB triggers Lambda to automate responses.

This combo keeps data fresh and apps responsive.

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