Why DynamoDB pairs with Lambda - Visual Breakdown

Concept Flow - Why DynamoDB pairs with Lambda

Event triggers Lambda

↓

Lambda runs code

↓

Lambda reads/writes DynamoDB

↓

DynamoDB stores/returns data

↓

Lambda processes response

↓

Lambda returns result or triggers next step

When an event happens, Lambda runs code that reads or writes data in DynamoDB, then processes the result.

Execution Sample

DynamoDB

exports.handler = async (event) => {
  const AWS = require('aws-sdk');
  const db = new AWS.DynamoDB.DocumentClient();
  const params = { TableName: 'Users', Key: { id: event.userId } };
  const data = await db.get(params).promise();
  return data.Item;
};

Lambda function triggered by event fetches a user record from DynamoDB and returns it.

Execution Table

Step	Action	Input/Condition	Result/Output
1	Lambda triggered	Event with userId=123	Lambda starts execution
2	Create DynamoDB client	AWS SDK loaded	db client ready
3	Prepare get params	TableName='Users', Key={id:123}	Params ready
4	Call db.get(params).promise()	Request sent to DynamoDB	DynamoDB fetches item
5	Receive data from DynamoDB	Item found with id=123	data.Item contains user record
6	Return data.Item	User record	Lambda returns user data
7	Lambda execution ends	No errors	Response sent to caller

💡 Lambda finishes after returning data from DynamoDB or error if any

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
event	{userId:123}	{userId:123}	{userId:123}	{userId:123}
params	undefined	{TableName:'Users', Key:{id:123}}	{TableName:'Users', Key:{id:123}}	{TableName:'Users', Key:{id:123}}
data	undefined	undefined	{Item:{id:123, name:'Alice'}}	{Item:{id:123, name:'Alice'}}

Key Moments - 2 Insights

Why does Lambda need to create a DynamoDB client inside the function?

Because Lambda runs code in a fresh environment each time, it must create the DynamoDB client to connect and send requests, as shown in step 2 of the execution_table.

What happens if DynamoDB does not find the item?

The data.Item will be undefined or null, so Lambda must handle this case after step 5 to avoid errors when returning data.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output at step 5?

A Lambda starts execution

B data.Item contains user record

C DynamoDB fetches item

D Response sent to caller

💡 Hint

Check the 'Result/Output' column at step 5 in the execution_table

At which step does Lambda prepare the parameters to query DynamoDB?

A Step 4

B Step 2

C Step 3

D Step 6

💡 Hint

Look at the 'Action' column describing parameter preparation in the execution_table

If the event had a different userId, how would the variable 'params' change?

A Key.id would change to the new userId

B It would stay the same

C TableName would change

D params would be undefined

💡 Hint

Check the variable_tracker for 'params' and how Key.id depends on event.userId

Concept Snapshot

Lambda runs code triggered by events
It creates a DynamoDB client to access data
Lambda sends requests to DynamoDB with parameters
DynamoDB returns data or empty result
Lambda processes and returns the data
This pairing enables serverless, event-driven data access

Full Transcript

This visual execution shows how AWS Lambda and DynamoDB work together. When an event triggers Lambda, it runs code that creates a DynamoDB client. Lambda prepares parameters to query DynamoDB, sends the request, and waits for the response. DynamoDB returns the requested data, which Lambda then processes and returns to the caller. This flow allows serverless applications to access and update data efficiently without managing servers.

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