Lambda function with DynamoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this Lambda function when querying DynamoDB?

Consider a Lambda function written in Node.js that queries a DynamoDB table named Users with a partition key userId. The function queries for userId = '123'. What will the function return if the item exists?

DynamoDB

import AWS from 'aws-sdk';
const dynamoDb = new AWS.DynamoDB.DocumentClient();

export const handler = async (event) => {
  const params = {
    TableName: 'Users',
    Key: { userId: '123' }
  };
  try {
    const data = await dynamoDb.get(params).promise();
    return data.Item || null;
  } catch (error) {
    return { error: error.message };
  }
};

A {"userId":"123","name":"Alice","age":30}

B null

C {"error":"ResourceNotFoundException"}

D {"userId":"123"}

💡 Hint

If the item exists, the get method returns the full item under data.Item.

The dynamoDb.get method returns an object with an Item property containing the item if found. If the item exists, it returns the full item data. If not found, Item is undefined, so the function returns null.

📝 Syntax

intermediate

Which option correctly updates an item in DynamoDB using Lambda?

You want to update the age attribute of a user with userId = '456' in DynamoDB using a Lambda function. Which code snippet is syntactically correct?

DynamoDB

import AWS from 'aws-sdk';
const dynamoDb = new AWS.DynamoDB.DocumentClient();

export const handler = async () => {
  const params = {
    TableName: 'Users',
    Key: { userId: '456' },
    UpdateExpression: 'set age = :a',
    ExpressionAttributeValues: { ':a': 35 },
    ReturnValues: 'UPDATED_NEW'
  };
  return await dynamoDb.update(params).promise();
};

A UpdateExpression: 'set age = :a', ExpressionAttributeValues: { ':a': 35 }

B UpdateExpression: 'set age = a', ExpressionAttributeValues: { 'a': 35 }

C UpdateExpression: 'set age = :a', ExpressionAttributeValues: { a: 35 }

D UpdateExpression: 'set age = :a', ExpressionAttributeValues: { ':a' => 35 }

💡 Hint

Expression attribute values must use placeholders starting with a colon : and be keys in an object.

The correct syntax requires the placeholder :a in the update expression and the corresponding key in ExpressionAttributeValues must be a string with the colon. Option A follows this syntax correctly.

❓ optimization

advanced

How to optimize a Lambda function to batch write multiple items to DynamoDB?

You want to insert 25 user records into a DynamoDB table in a single Lambda invocation. Which approach is the most efficient and correct?

A Call <code>dynamoDb.put</code> 25 times in parallel without waiting for promises.

B Call <code>dynamoDb.put</code> 25 times sequentially inside a loop.

C Use <code>dynamoDb.update</code> with 25 update expressions in one call.

D Use <code>dynamoDb.batchWrite</code> with up to 25 <code>PutRequest</code> items in one call.

💡 Hint

DynamoDB supports batch writes with a limit of 25 items per batch.

Using batchWrite with up to 25 items is the most efficient way to insert multiple items in one request. Calling put multiple times is less efficient and may cause throttling.

🔧 Debug

advanced

Why does this Lambda function fail with a ProvisionedThroughputExceededException?

This Lambda function writes items to DynamoDB but sometimes fails with ProvisionedThroughputExceededException. What is the likely cause?

DynamoDB

import AWS from 'aws-sdk';
const dynamoDb = new AWS.DynamoDB.DocumentClient();

export const handler = async (event) => {
  const params = {
    TableName: 'Users',
    Item: event.item
  };
  try {
    await dynamoDb.put(params).promise();
    return { status: 'success' };
  } catch (error) {
    return { error: error.code };
  }
};

A The AWS SDK is not configured with correct credentials.

B The Item parameter is missing a required attribute.

C The function is writing too many items too quickly, exceeding the table's write capacity.

D The table name 'Users' is misspelled.

💡 Hint

ProvisionedThroughputExceededException means the request rate is too high for the provisioned capacity.

This error occurs when the number of write requests exceeds the provisioned write capacity units of the DynamoDB table. The function likely writes too fast or in bursts.

🧠 Conceptual

expert

What is the best practice for handling DynamoDB pagination in a Lambda function?

You query a DynamoDB table with a large dataset that returns paginated results. How should your Lambda function handle pagination to retrieve all items efficiently?

A Set <code>Limit</code> to a very high number to get all items in one query call.

B Use the <code>LastEvaluatedKey</code> from the query response to iteratively request the next page until no more keys remain.

C Ignore pagination and process only the first page of results.

D Use <code>Scan</code> instead of <code>Query</code> to avoid pagination.

💡 Hint

DynamoDB paginates query results and provides LastEvaluatedKey to continue fetching.

To retrieve all items, the Lambda function should check if LastEvaluatedKey exists in the response and use it as ExclusiveStartKey in the next query call, repeating until no key remains.

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