Lambda function with DynamoDB - Step-by-Step Execution

Concept Flow - Lambda function with DynamoDB

Event triggers Lambda

↓

Lambda starts execution

↓

Lambda reads event data

↓

Lambda calls DynamoDB API

↓

DynamoDB processes request

↓

DynamoDB returns response

↓

Lambda processes response

↓

Lambda returns result or error

This flow shows how a Lambda function is triggered, interacts with DynamoDB, and returns a result.

Execution Sample

DynamoDB

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

This Lambda function fetches a user item from DynamoDB based on userId from the event.

Execution Table

Step	Action	Input/Condition	DynamoDB Call	Response	Output
1	Lambda triggered	event.userId = '123'	No	No	Start execution
2	Create DynamoDB client	AWS SDK loaded	No	No	Client ready
3	Prepare params	TableName='Users', Key={userId:'123'}	No	No	Params ready
4	Call db.get(params).promise()	params as above	GetItem on 'Users' with Key userId='123'	Returns item {userId:'123', name:'Alice'}	Data received
5	Return data.Item	Item exists	No	No	Returns {userId:'123', name:'Alice'}
6	Lambda execution ends	No	No	No	Response sent

💡 Lambda finishes after returning the DynamoDB item or error if any

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
event.userId	'123'	'123'	'123'	'123'	'123'
db	undefined	AWS.DynamoDB.DocumentClient instance	AWS.DynamoDB.DocumentClient instance	AWS.DynamoDB.DocumentClient instance	AWS.DynamoDB.DocumentClient instance
params	undefined	undefined	{ TableName: 'Users', Key: { userId: '123' } }	{ TableName: 'Users', Key: { userId: '123' } }	{ TableName: 'Users', Key: { userId: '123' } }
data	undefined	undefined	undefined	{ Item: { userId: '123', name: 'Alice' } }	{ Item: { userId: '123', name: 'Alice' } }
return value	undefined	undefined	undefined	undefined	{ userId: '123', name: 'Alice' }

Key Moments - 3 Insights

Why do we use 'await' before the DynamoDB call?

Because the DynamoDB call returns a promise, 'await' pauses Lambda execution until the data is returned, as shown in step 4 of the execution_table.

What happens if the item with userId '123' does not exist?

The 'data.Item' will be undefined, so the Lambda will return undefined or null. This is implied in step 5 where the item is returned if it exists.

Why do we create a new DynamoDB client inside the Lambda handler?

To interact with DynamoDB, the Lambda needs a client instance, created at step 2, which allows calling DynamoDB APIs.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'params' after step 3?

A undefined

B { TableName: 'Users', Key: { userId: '123' } }

C { userId: '123' }

D AWS.DynamoDB.DocumentClient instance

💡 Hint

Check the 'params' variable in variable_tracker after step 3

At which step does the Lambda function receive the data from DynamoDB?

A Step 4

B Step 2

C Step 5

D Step 6

💡 Hint

Look at the 'Response' column in execution_table where DynamoDB returns the item

If the event.userId was missing, what would change in the execution?

A Lambda would return a default item

B Lambda would skip DynamoDB call

C DynamoDB call would fail or return no item

D Lambda would create a new user

💡 Hint

Consider how 'params' depends on event.userId in variable_tracker and execution_table

Concept Snapshot

Lambda function with DynamoDB:
- Lambda triggered by event
- Create DynamoDB client inside Lambda
- Prepare params with TableName and Key
- Use await db.get(params).promise() to fetch item
- Return data.Item as Lambda response
- Handle missing items gracefully

Full Transcript

This visual execution shows how a Lambda function interacts with DynamoDB. When the Lambda is triggered, it reads the event data, creates a DynamoDB client, prepares parameters for the query, calls DynamoDB to get an item, waits for the response, and returns the item. Variables like event.userId, params, and data change step-by-step. Key moments include understanding the use of await, handling missing items, and why the client is created inside Lambda. The quiz questions help reinforce these steps by referencing the execution table and variable states.

Practice

1. What is the main purpose of using a Lambda function with DynamoDB in AWS?

easy

A. To run code automatically when DynamoDB data changes

B. To manually update DynamoDB tables from the AWS console

C. To create new DynamoDB tables without coding

D. To backup DynamoDB data to S3 manually

Solution

1. Step 1: Understand Lambda triggers

   Lambda functions can be triggered by events, such as changes in DynamoDB tables.

2. Step 2: Identify the purpose of automation

   This allows automatic code execution when data changes, without manual intervention.

3. Final Answer:

   To run code automatically when DynamoDB data changes -> Option A

4. Quick Check:

   Lambda triggers = automatic code run [OK]

Hint: Lambda runs code on events like DynamoDB changes [OK]

Common Mistakes:

• Thinking Lambda manually updates tables
• Confusing Lambda with backup tools
• Assuming Lambda creates tables automatically

2. Which of the following is the correct way to initialize AWS DynamoDB DocumentClient in a Node.js Lambda function?

easy

A. const docClient = new AWS.DynamoDBClient();

B. const docClient = new AWS.DynamoDB.DocumentClient();

C. const docClient = AWS.DynamoDB.DocumentClient();

D. const docClient = AWS.DynamoDB.Document();

Solution

1. Step 1: Recall correct DocumentClient syntax

   The AWS SDK requires using 'new' keyword to create a DocumentClient instance.

2. Step 2: Match correct class name and usage

   The correct class is AWS.DynamoDB.DocumentClient, not DynamoDBClient or Document.

3. Final Answer:

   const docClient = new AWS.DynamoDB.DocumentClient(); -> Option B

4. Quick Check:

   Use 'new' with DocumentClient class [OK]

Hint: Use 'new AWS.DynamoDB.DocumentClient()' to initialize [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using wrong class name like DynamoDBClient
• Calling Document() instead of DocumentClient

3. Given this Lambda function snippet, what will be the output if the item with id '123' exists in the DynamoDB table?

const AWS = require('aws-sdk');
const docClient = new AWS.DynamoDB.DocumentClient();

exports.handler = async (event) => {
  const params = {
    TableName: 'Users',
    Key: { id: '123' }
  };
  const data = await docClient.get(params).promise();
  return data.Item;
};

medium

A. An error because 'get' method is incorrect

B. A list of all items in the Users table

C. An empty object {}

D. The item object with id '123' from the Users table

Solution

1. Step 1: Understand docClient.get usage

   The get method retrieves a single item by key from the specified table.

2. Step 2: Analyze the return value

   If the item with id '123' exists, data.Item will contain that item object.

3. Final Answer:

   The item object with id '123' from the Users table -> Option D

4. Quick Check:

   docClient.get returns item if found [OK]

Hint: docClient.get returns single item by key [OK]

Common Mistakes:

• Expecting a list instead of single item
• Thinking get method is invalid
• Assuming empty object if item exists

4. Identify the error in this Lambda function code that writes an item to DynamoDB:

const AWS = require('aws-sdk');
const docClient = new AWS.DynamoDB.DocumentClient();

exports.handler = async (event) => {
  const params = {
    TableName: 'Products',
    Item: {
      productId: '001',
      name: 'Book'
    }
  };
  await docClient.putItem(params).promise();
  return 'Success';
};

medium

A. Using 'putItem' instead of 'put' method on DocumentClient

B. Missing 'Key' property in params

C. TableName should be lowercase

D. Missing callback function in putItem

Solution

1. Step 1: Check DocumentClient method names

   DocumentClient uses 'put' method, not 'putItem'.

2. Step 2: Confirm correct method usage

   Using 'putItem' causes a runtime error because it does not exist on DocumentClient.

3. Final Answer:

   Using 'putItem' instead of 'put' method on DocumentClient -> Option A

4. Quick Check:

   Use 'put' to write items with DocumentClient [OK]

Hint: Use 'put', not 'putItem', with DocumentClient [OK]

Common Mistakes:

• Confusing low-level DynamoDB client with DocumentClient
• Assuming 'putItem' exists in DocumentClient
• Ignoring method naming conventions

5. You want a Lambda function to update a user's email in DynamoDB only if the user exists. Which approach correctly ensures this conditional update?

hard

A. Use docClient.delete before updating

B. Use docClient.put without any condition

C. Use docClient.update with ConditionExpression 'attribute_exists(id)'

D. Use docClient.get and then docClient.put unconditionally

Solution

1. Step 1: Understand conditional update in DynamoDB

   To update only if an item exists, use ConditionExpression with 'attribute_exists' on the key.

2. Step 2: Apply ConditionExpression in update method

   docClient.update supports ConditionExpression to prevent overwriting non-existing items.

3. Step 3: Evaluate other options

   Using put without condition overwrites or creates new items; delete before update is inefficient; get then put is not atomic.

4. Final Answer:

   Use docClient.update with ConditionExpression 'attribute_exists(id)' -> Option C

5. Quick Check:

   Conditional update = update + attribute_exists [OK]

Hint: Use ConditionExpression 'attribute_exists' for safe updates [OK]

Common Mistakes:

• Using put which overwrites without condition
• Deleting item before update unnecessarily
• Not using atomic conditional update