DVA-C03 Practice Exam: 700 Questions with Explanations

1. A developer is building a Lambda function for a billing platform. The function generates PDF invoices and writes them to an S3 bucket. Compliance requires that the function hold no long-term credentials and be able to write only to that one bucket. What is the MOST secure way to configure this?

1. Create an IAM execution role with a policy that allows s3:PutObject only on the invoice bucket and attach the role to the function
2. Create an IAM user for the application, store its access keys in a plaintext environment variable, and rotate them monthly
3. Attach the AmazonS3FullAccess managed policy to the function's execution role so future buckets work without changes
4. Embed the account root credentials in the deployment package so the function always has access

2. A Lambda function that processes orders must also run inside a VPC to reach a private RDS database. After the developer attaches the function to private subnets, calls from the function to the public DynamoDB API start timing out. What should the developer do to restore DynamoDB access with the least operational overhead?

1. Move the function out of the VPC and connect to RDS over the public internet
2. Create a NAT gateway in a public subnet and route the private subnets' internet-bound traffic through it
3. Add a gateway VPC endpoint for DynamoDB to the route tables of the private subnets
4. Give each private subnet a public IP range so the function can reach AWS APIs directly

3. A developer needs to share a set of utility libraries and a custom JSON-parsing binary across twelve Lambda functions written by different teams. The shared code changes about once a month and must be deployable independently of each function. Which approach meets these requirements?

1. Copy the libraries into every function's deployment package and redeploy all twelve on each change
2. Package the shared code as a Lambda layer and attach the layer version to each function
3. Store the libraries in an S3 bucket and download them to /tmp on every cold start
4. Merge the twelve functions into one large function that contains all the shared code

4. A retail company's Lambda function validates shopping carts. During flash sales, bursts of invocations overwhelm a downstream inventory API that can only handle 200 concurrent calls. The developer must cap the function's concurrency while still accepting events. Which configuration achieves this?

1. Set the function's reserved concurrency to 200
2. Set the function's provisioned concurrency to 200
3. Lower the function's memory allocation so each invocation runs more slowly
4. Reduce the account-level concurrency quota through a Service Quotas request

5. A Java Lambda function that serves a customer-facing API has unacceptable cold-start latency because of heavy framework initialization. The team cannot rewrite the application. Which feature MOST directly reduces the initialization latency?

1. Increase the function's memory allocation to its maximum
2. Enable Lambda SnapStart for the function
3. Move the function to a container image deployment
4. Place the function inside a VPC with enhanced networking

6. A Lambda function triggered by SQS must process each message, but occasionally a single malformed message causes the entire batch of ten to be retried and reprocessed. The developer wants only the failed messages returned to the queue. How should the function be configured?

1. Reduce the SQS batch size to 1 in the event source mapping
2. Enable partial batch responses on the SQS event source mapping and return the message IDs of only the failed items
3. Set the queue's visibility timeout to zero so failures are visible immediately
4. Configure a dead-letter queue on the function and let Lambda move the whole batch there

7. A developer is choosing how to expose a new Lambda function as an HTTPS endpoint for an internal tool. The tool needs simple request/response behavior, its own custom domain, and the lowest cost, and does not need request validation, usage plans, or API keys. Which option is the best fit?

1. Create a REST API in API Gateway with a Lambda proxy integration
2. Create a Lambda function URL and map the custom domain to it
3. Create a WebSocket API in API Gateway for persistent connections
4. Put an Application Load Balancer in front of the function with a Lambda target group

8. A data-processing Lambda function downloads a 700 MB reference dataset at startup and needs scratch space for intermediate files larger than the default ephemeral storage allows. What should the developer configure?

1. Increase the function's /tmp ephemeral storage allocation, up to 10 GB
2. Write intermediate files to the function's read-only deployment directory
3. Mount the function's own zip package as a writable file system
4. Store all intermediate files as Lambda environment variables

9. A developer notices a Python Lambda function is CPU-bound when compressing files: execution time barely drops when the timeout is raised, but billing duration is high. Which change will MOST improve its performance?

1. Increase the function's configured memory, which proportionally increases allocated CPU
2. Decrease the memory so the function is throttled into running longer batches
3. Split the function into ten chained functions that each compress part of the file
4. Enable Lambda SnapStart to warm the compression libraries

10. A nightly reconciliation job written as a single Lambda function now needs to run for about 40 minutes and includes pauses where it waits for an external approval. Which approach should the developer take?

1. Raise the Lambda timeout above 15 minutes by requesting a quota increase
2. Split the job into steps orchestrated by AWS Step Functions, with Lambda functions performing each task
3. Run the Lambda function recursively so each invocation restarts the timer
4. Keep the job in Lambda but store progress in environment variables between invocations

11. A developer must deploy a Lambda function whose dependency stack is 6 GB, far above the zip deployment limit. Which deployment method supports this with the LEAST change to the team's workflow?

1. Split the zip into several functions that share variables through Parameter Store
2. Deploy the function as a container image stored in Amazon ECR
3. Compress the dependencies with a Lambda layer stack of five layers
4. Base64-encode the package and pass it as an environment variable

12. EXHIBIT — A payments team reviews the configuration of a production Lambda function and its recent behavior: Function configuration: Memory 128 MB; Timeout 3 seconds; Runtime: Python 3.12; Handler performs JSON parsing of large payloads, three sequential calls to an internal pricing API, and writes results to DynamoDB. Observed behavior: p50 duration 2,850 ms; frequent DurationExceeded timeouts at peak; CPU utilization reported as saturated; error rate rises with payload size. The team can change ONE setting first and wants the change most likely to remove the timeouts. Which change should they make?

1. Increase the memory allocation to 1,024 MB
2. Increase the timeout to 15 minutes
3. Move the function into a VPC
4. Enable provisioned concurrency with 20 units

13. A Lambda function is invoked asynchronously to generate reports. When the downstream report service is down for an hour, all events from that hour are lost because retries are exhausted. The developer must ensure failed asynchronous invocations are preserved for later reprocessing. What should be configured?

1. A dead-letter queue (SQS queue or SNS topic) on the function for failed asynchronous events
2. A higher reserved concurrency so retries happen faster
3. Synchronous invocation from the caller so errors surface immediately
4. Lambda destinations on success only, writing to an S3 bucket

14. A developer's Lambda function creates a new database connection inside the handler on every invocation, causing connection storms during bursts. Which coding pattern fixes this with the least effort?

1. Move connection creation outside the handler so it is created once per execution environment and reused across invocations
2. Store the connection object in an S3 bucket and fetch it for each request
3. Force a cold start before each invocation by publishing a new function version
4. Increase the database's maximum connection limit to absorb the storm

15. A healthcare application stores configuration in Lambda environment variables, but the combined size of the values now exceeds the 4 KB limit. The values include a database connection string that must stay encrypted. What should the developer do?

1. Compress the environment variables with gzip before setting them
2. Move the configuration to AWS Systems Manager Parameter Store or Secrets Manager and retrieve it at runtime with caching in the function
3. Split the configuration across two Lambda functions that call each other
4. Store the values in the function's tags instead of environment variables

16. A developer wants a Lambda function to process very large product-catalog files (up to 2 GB) that several other services also need to read and update concurrently. Which storage option fits Lambda's model best?

1. Mount an Amazon EFS file system to the function and process the files in place
2. Use the function's /tmp storage and accept that other services cannot see the files
3. Store the files in DynamoDB items split into 400 KB chunks
4. Keep the files in the deployment package and rebuild it for each update

17. A public API backed by Lambda returns recommendation payloads of up to 20 MB. Clients complain that responses are buffered and arrive all at once, and some large responses fail. Which Lambda feature addresses this?

1. Lambda response streaming, which progressively streams the response to the client
2. Raising the function's memory so the payload is generated faster
3. Returning the payload as a base64 string inside a JSON envelope
4. Increasing the API payload quota for the account through Service Quotas

18. A developer invokes a Lambda function synchronously from a mobile backend and passes a 9 MB document for analysis. The invoke calls fail with a payload size error. What is the recommended pattern?

1. Split the document into 6 MB chunks and invoke the function once per chunk
2. Upload the document to S3 and pass the bucket and key in a small event payload for the function to fetch
3. Compress the document with base64 encoding before sending it
4. Switch the function to a container image so payload limits no longer apply

19. A fintech team must prove that only Lambda code they built and approved runs in production. They need Lambda to verify a signature before deploying function code. Which feature provides this?

1. Lambda code signing with AWS Signer, configured to reject unsigned deployments
2. VPC endpoints for the Lambda API so deployments stay on the private network
3. Lambda layers with version pinning so old code cannot change
4. S3 Versioning on the bucket that stores deployment packages

20. A developer troubleshooting a Lambda function notices the same SQS message being processed repeatedly and suspects the function is calling itself indirectly through an S3 notification chain, creating a runaway loop. Which Lambda capability helps stop this class of problem, and what should the developer also do? (Select the best single answer.)

1. Use Lambda's recursive loop detection, which stops invocations in supported service chains, and redesign the chain to break the cycle
2. Disable the function's execution role so the loop cannot continue
3. Set the function's reserved concurrency to zero permanently and delete its event source mappings so no trigger can ever restart the loop
4. Turn off CloudWatch Logs so the loop is no longer visible

21. A developer wants to minimize cost for a CPU-bound Lambda function by choosing the right memory setting. Which reasoning is CORRECT?

1. 10,240 MB, because maximum CPU always finishes the work fastest, and the shortest possible duration always produces the lowest overall bill
2. The smallest memory of 128 MB, because it carries the lowest per-GB-second rate and the lowest possible charge for each invocation
3. Provisioned concurrency, because pre-warmed environments make invocations free of duration charges and remove any need to tune memory
4. An intermediate setting such as 1,769 MB (one full vCPU), because cost is memory multiplied by duration and added CPU shortens the duration

22. A Java application uses Lambda SnapStart. After enabling it, sessions intermittently fail because every restored environment presents the same cached access token. What is the correct fix for SnapStart-based functions?

1. Hard-coding database credentials so no network call is needed at restore
2. Embedding the current timestamp in a static variable initialized before the snapshot
3. Declaring all variables static so they can never change after restore
4. Using the after-restore runtime hook to refresh values that must be unique per environment, such as credentials fetched at runtime

23. A team is migrating its client applications to IPv6-only networking. The clients invoke an AWS Lambda function over the internet, and the team needs those invocations to work over IPv6 without changing the function code. Which Lambda capability supports this scenario?

1. Deploy the function behind CloudFront Functions instead
2. Use S3 as an intermediary to carry requests to the function
3. Invoke the function through its dual-stack endpoint name so IPv6 clients can reach it
4. Move the workload to a Region that has no IPv4-only services

24. A Lambda function consumes an SQS queue that carries many event types, but the function only cares about 'order.shipped' events; it still gets invoked for every batch. How can the developer reduce wasted invocations without adding code?

1. Filtering records inside the handler as the first line of code
2. A dead-letter queue on the source queue
3. Reducing the event source batch size to 1
4. Event filtering patterns on the event source mapping

25. A developer sets a Lambda function's timeout to 25 minutes for a video analysis task and finds the setting rejected. Which statement is TRUE?

1. Request a Service Quotas increase for the function timeout
2. Switch the function from a zip package to a container image
3. The timeout cannot exceed 15 minutes; redesign the job as shorter steps, for example with Step Functions
4. Enable provisioned concurrency so the function is allowed to run longer

26. A developer adds a scheduled ping every 5 minutes to keep a Lambda function warm, but users still see cold starts when a burst of 300 requests arrives. Why is the warm-up ineffective? (Select the best single answer.)

1. The function's memory is too small for the warm-up to help
2. Provisioned concurrency is already configured for the function, so the remaining issue is that callers use the wrong invocation type for bursts of traffic
3. A burst of 300 concurrent requests needs roughly 300 execution environments, and one scheduled warm-up only ever warms a single environment
4. The function is attached to a VPC, which blocks scheduled warm-up events from reaching it

27. A Lambda function renders customer statements. Profiling shows that most of the per-invocation time is spent loading and compiling a template file, even though the template changes only when code is redeployed. What is the most effective optimization?

1. Increase memory to speed repeated compilation
2. Schedule the function to restart hourly
3. Fetch and compile the template from S3 inside the handler on each request
4. Load and compile the template outside the handler at initialization time

28. A payments Lambda function can be invoked more than once for the same order because its SQS trigger delivers at least once. The team wants a managed, low-code way to make handler execution idempotent. Which approach fits best?

1. Configure the SQS redrive policy with maxReceiveCount of 1
2. Turn on exactly-once delivery for the trigger in the Lambda console
3. Use the Lambda Powertools idempotency utility backed by DynamoDB to record completed request keys and short-circuit duplicates
4. Check the source IP address of each invocation and ignore repeats

29. A suite of Lambda functions fronts an Aurora MySQL database. At peak, hundreds of execution environments each open their own connections and exhaust the database's connection limit. Which service should the developer place in front of the database?

1. Store open connections in /tmp so later invocations reuse them
2. Cache the database password in the function to avoid Secrets Manager calls
3. Put Amazon RDS Proxy between the functions and the database so connection pooling is shared across execution environments
4. Raise the function's reserved concurrency so fewer environments exist

30. A developer wants better price-performance for a fleet of Python Lambda functions that have no compiled x86-specific dependencies. Which change does Lambda support?

1. SnapStart must be disabled before switching architectures
2. The function must be moved out of the VPC to run on Graviton
3. API callers must be updated to send an architecture header with every request so Lambda can route the calls to Graviton processors
4. Deploy the same code on arm64 by changing the function's architecture setting and rebuilding any native dependencies for arm64