DVA-C02 Lambda Events, VPC Access, and Errors Guide

Lambda is central to DVA-C02, but the exam is not just asking whether you know Lambda exists. It is testing whether you understand how runtime settings, event-source semantics, VPC access, retries, destinations, and code shape change real application behavior.

Dead-letter queue (DLQ): Queue or topic that receives records that could not be processed successfully after the normal retry path.

Destination: Configured target that receives a record of successful or failed asynchronous Lambda invocation results.

What AWS is really testing here

The stem usually wants you to classify one of these lanes:

• execution settings such as memory, timeout, concurrency, runtime, layers, or environment variables
• event lifecycle behavior for synchronous, asynchronous, or poll-based triggers
• failure handling through DLQs, destinations, retries, and idempotent code
• access from Lambda into private VPC resources

High-yield chooser

Trigger model first, tuning second

The fastest way to miss Lambda questions is to start with memory or timeout before understanding the trigger model.

If the question mentions duplicates or delayed retries, think about the event-source model before you think about raw compute sizing.

Lambda configuration is application behavior

At the developer level, these settings are not “just ops knobs”:

• memory changes both available memory and CPU share
• timeout changes how long the function can safely wait on downstream systems
• reserved concurrency can protect downstream systems from overload
• environment variables should hold configuration, not embedded secrets
• layers and extensions solve different packaging and runtime concerns

Small Python example:

 1import json
 2import os
 3
 4TABLE_NAME = os.environ["TABLE_NAME"]
 5
 6def handler(event, context):
 7    record_id = event["id"]
 8    return {
 9        "statusCode": 200,
10        "body": json.dumps({"table": TABLE_NAME, "recordId": record_id}),
11    }

The exam point is that configuration belongs outside the code artifact when the value changes across environments.

VPC access changes the operational shape

When Lambda needs private resources such as an RDS instance in private subnets, the exam expects you to remember:

• Lambda can attach to a VPC
• subnet and security-group choices matter
• access to private resources works differently from plain public-service access
• reachability failures often come from networking design, not handler logic

Many DVA-C02 distractors pretend VPC access is only an infrastructure detail. For developers, it directly affects application reachability and failure modes.

Idempotency and retry-aware code

This is one of the most important practical developer skills in the exam.

1def process_order(event, seen_ids: set[str]) -> str:
2    order_id = event["orderId"]
3    if order_id in seen_ids:
4        return "duplicate ignored"
5
6    # perform side effect once
7    seen_ids.add(order_id)
8    return "processed"

In production you would back this with durable state, not an in-memory set. The exam lesson is simpler: if retries or replays can happen, the handler must avoid duplicating side effects such as extra charges, double emails, or repeated downstream writes.

Performance tuning for the developer lane

DVA-C02 does not expect deep Lambda micro-benchmarking. It does expect you to know the common first moves:

• increase memory when the function is CPU-constrained or slow
• use reserved concurrency to protect a fragile dependency
• keep handlers efficient and reuse clients where appropriate
• keep packages lean when startup time matters

If the issue is repeated failure under retries, tuning alone is usually the wrong first answer.

Common traps

• increasing timeout when the real problem is bad downstream design or no buffering
• assuming every failed invocation is handled the same way regardless of trigger type
• forgetting that reserved concurrency can protect downstream systems
• treating Lambda layers and extensions as interchangeable
• putting secrets directly into code instead of using a safer configuration path

Decision order that usually wins

1. Decide whether the Lambda problem is mainly side-effect safety, network reachability, invocation model, or resource tuning.
2. If retries could create duplicate side effects, think idempotent handler design before memory or timeout tuning.
3. If the function must reach a private resource, move into the VPC access and networking lane first.
4. Keep invocation retries and compute sizing in separate buckets because the exam often mixes them.
5. Treat Lambda as application behavior plus integration behavior, not only as a runtime knob.

Quiz