Lambda execution model in AWS - Step-by-Step Execution

Process Flow - Lambda execution model

Event triggers Lambda

↓

Lambda service receives event

↓

Check for existing container

↓

Reuse container

↓

Run handler code inside container

↓

Return response or error

↓

Container kept warm or terminated

This flow shows how AWS Lambda receives an event, checks for a container to run the code, executes the handler, and then either keeps the container ready or ends it.

Execution Sample

AWS

def lambda_handler(event, context):
    print('Start')
    result = event['value'] * 2
    print('End')
    return result

A simple Lambda function that doubles a value from the event and prints start and end messages.

Process Table

Step	Action	Container State	Handler Execution	Output
1	Event triggers Lambda	No container	Not started	None
2	Create new container	Container created	Not started	None
3	Run handler code	Container active	Print 'Start'	None
4	Process event data	Container active	Calculate result = value * 2	None
5	Run handler code	Container active	Print 'End'	None
6	Return result	Container active	Return doubled value	Result returned
7	Container kept warm	Container ready for next event	Idle	None
8	No new event arrives	Container terminated after timeout	Stopped	None

💡 Execution stops when no new events arrive and container is terminated after idle timeout.

Status Tracker

Variable	Start	After Step 4	After Step 6	Final
event['value']	5 (example)	5	5	5
result	undefined	10	10	10
container_state	No container	Container active	Container active	Container terminated

Key Moments - 3 Insights

Why does Lambda sometimes create a new container and sometimes reuse an existing one?

Lambda reuses containers to save time on startup. If a container is available (see Step 3), it runs the handler there. If not, it creates a new container (Step 2).

What happens to the container after the Lambda function finishes running?

After returning the result (Step 6), the container stays warm for a while (Step 7) to handle new events quickly, then terminates if idle (Step 8).

Does the variable 'result' keep its value between Lambda invocations?

No, each invocation runs fresh code. Variables like 'result' are reset each time the handler runs (Step 4 and 6).

Visual Quiz - 3 Questions

Look at the execution table, at which step is the handler code first executed?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Check the 'Handler Execution' column for when 'Print Start' happens.

According to the variable tracker, what is the value of 'result' after Step 4?

A undefined

B 5

C 10

D None

💡 Hint

Look at the 'result' row under 'After Step 4' column.

If no new event arrives, what happens to the container according to the execution table?

A It stays active indefinitely

B It is kept warm for a while then terminated

C It immediately terminates after Step 6

D It restarts automatically

💡 Hint

See Steps 7 and 8 in the 'Container State' column.

Concept Snapshot

AWS Lambda execution model:
- Event triggers Lambda service
- Lambda checks for existing container
- Reuses container or creates new one
- Runs handler code inside container
- Returns result
- Container kept warm for reuse or terminated after idle
- Variables reset each invocation

Full Transcript

AWS Lambda runs code in response to events. When an event arrives, Lambda checks if a container is ready. If not, it creates one. Then it runs your handler code inside that container. After running, it returns the result. The container stays ready for a short time to handle more events quickly. If no events come, the container shuts down. Variables inside your code reset each time the handler runs.

Practice

1. What happens when an AWS Lambda function is not triggered by any event?

easy

A. The function does not run and no charges occur.

B. The function runs continuously in the background.

C. The function runs once every hour automatically.

D. The function runs only when manually started from the console.

Solution

1. Step 1: Understand Lambda's event-driven model

   A Lambda function runs only when triggered by an event, such as an API call or file upload.

2. Step 2: Consider billing and execution behavior

   If no event triggers the function, it does not execute and you are not charged.

3. Final Answer:

   The function does not run and no charges occur. -> Option A

4. Quick Check:

   Lambda runs only on events = C [OK]

Hint: Lambda runs only on events, no event means no run [OK]

Common Mistakes:

• Thinking Lambda runs continuously without events
• Assuming Lambda runs on a schedule by default
• Believing manual start is required for all executions

2. Which of the following is the correct way to define a Lambda handler function in Python?

easy

A. def handler(): print('Hello World')

B. function handler(event) { return 'Hello World'; }

C. handler(event, context) => { return 'Hello World'; }

D. def handler(event, context): return 'Hello World'

Solution

1. Step 1: Recall Python Lambda handler signature

   In Python, the handler must accept two parameters: event and context.

2. Step 2: Check syntax correctness

   def handler(event, context): return 'Hello World' correctly defines a Python function with event and context and returns a string.

3. Final Answer:

   def handler(event, context): return 'Hello World' -> Option D

4. Quick Check:

   Python handler(event, context) = A [OK]

Hint: Python Lambda handlers need event and context parameters [OK]

Common Mistakes:

• Using JavaScript syntax in Python handler
• Omitting context parameter
• Defining handler without parameters

3. Given this Python Lambda handler code:

def handler(event, context):
    return event['value'] * 2

What is the output if the event is {"value": 5}?

medium

A. Error: 'value' key missing

B. 5

C. 10

D. None

Solution

1. Step 1: Understand the handler logic

   The handler multiplies the 'value' from event by 2.

2. Step 2: Calculate output for event {'value': 5}

   5 * 2 = 10, so the function returns 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   5 times 2 equals 10 [OK]

Hint: Multiply event['value'] by 2 for output [OK]

Common Mistakes:

• Confusing event keys or missing them
• Assuming function returns input unchanged
• Expecting error when key exists

4. This Lambda function code causes an error when triggered:

def handler(event, context):
    return event['data'] * 3

What is the likely cause?

medium

A. The function is missing the context parameter.

B. The event dictionary does not have the 'data' key.

C. The return statement syntax is incorrect.

D. Lambda functions cannot multiply values.

Solution

1. Step 1: Identify cause of error in code

   The function tries to access event['data'], which may not exist.

2. Step 2: Understand error from missing key

   If 'data' key is missing in event, a KeyError occurs causing the function to fail.

3. Final Answer:

   The event dictionary does not have the 'data' key. -> Option B

4. Quick Check:

   Missing event key causes error = B [OK]

Hint: Check if event keys exist before using them [OK]

Common Mistakes:

• Assuming context parameter missing causes error
• Thinking return syntax is wrong
• Believing Lambda cannot do arithmetic

5. You want your Lambda function to process multiple events concurrently without waiting for previous executions. Which Lambda feature supports this behavior?

hard

A. Automatic scaling with multiple concurrent executions

B. Manual start of multiple Lambda instances

C. Scheduled triggers to queue events

D. Using a single-threaded execution model

Solution

1. Step 1: Understand Lambda concurrency

   Lambda automatically scales by running multiple instances to handle events concurrently.

2. Step 2: Eliminate incorrect options

   Manual start and single-threaded models do not support concurrency; scheduled triggers queue events but don't scale automatically.

3. Final Answer:

   Automatic scaling with multiple concurrent executions -> Option A

4. Quick Check:

   Lambda auto-scales for concurrency = D [OK]

Hint: Lambda auto-scales to run many events at once [OK]

Common Mistakes:

• Thinking manual start is needed for concurrency
• Confusing scheduling with scaling
• Assuming Lambda runs single-threaded only