Lambda function with DynamoDB - Time & Space Complexity

Time Complexity: Lambda function with DynamoDB

O(1)

Understanding Time Complexity

When using a Lambda function to interact with DynamoDB, it's important to understand how the time it takes to run changes as the data grows.

We want to know how the number of operations grows when the database or input size increases.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

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

This Lambda function fetches a single user record from DynamoDB by its userId key.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: A single DynamoDB GetItem request to fetch one record.
• How many times: Exactly once per Lambda invocation.

How Execution Grows With Input

Since the function fetches one item by key, the time does not increase with the total number of items in the table.

Input Size (n)	Approx. Operations
10	1 Get request
100	1 Get request
1000	1 Get request

Pattern observation: The number of operations stays the same no matter how many records are in the table.

Final Time Complexity

Time Complexity: O(1)

This means the time to get one item stays constant, no matter how big the database grows.

Common Mistake

[X] Wrong: "Getting an item from DynamoDB takes longer as the table gets bigger."

[OK] Correct: DynamoDB uses keys to directly find items, so fetching one item by key is fast and does not slow down with more data.

Interview Connect

Understanding how database calls scale helps you write efficient serverless functions and shows you know how to handle data growth gracefully.

Self-Check

"What if the Lambda function scanned the entire table instead of getting by key? How would the time complexity change?"

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