In AWS Lambda, CPU power scales proportionally with the memory configuration. Lambda does not let you directly set "CPU cores" as a standalone setting in the general case; instead, increasing the function's configured memory increases the CPU allocation (and other resources such as network throughput) available to the function. Therefore, to reduce latency caused by insufficient CPU, the developer should increase the function's memory setting.
Option B directly addresses the CPU limitation in the supported Lambda configuration model. This is a common performance tuning approach: raise memory, benchmark, and find the optimal cost/performance point.
Option A is not the right lever for most Lambda functions because Lambda compute is configured via memory (and architecture), not by directly raising a "vCPU quota" per function in a typical tuning workflow.
Option C increases /tmp storage capacity and helps when dealing with large temporary files, not CPU availability.
Option D increases the maximum runtime allowed per invocation, but it does not give the function more CPU and will not reduce latency caused by CPU starvation.
Therefore, increasing the allocated memory is the correct way to increase CPU for a Lambda function.

* Why Option C is Correct:Implementing a connection pool in the Redis client reduces connection overhead and avoids frequent connection establishment, which helps to reduce latency and connection failures.
* Why Other Options are Incorrect:
* Option A: Exponential backoff retry strategies help with transient failures but do not resolve latency caused by frequent connection establishment.
* Option B: Storing scores in application memory adds complexity and risks inconsistency.
* Option D: Adding more nodes is unnecessary unless the cluster is under heavy load. Latency due to connection failures is better addressed at the application level.
* AWS Documentation References:
* Amazon ElastiCache Best Practices

The most operationally efficient way to remove time-bound data from a DynamoDB table is to use Time to Live (TTL). TTL is a DynamoDB feature that lets you define an attribute (typically a Unix epoch timestamp) that represents an item's expiration time. After the timestamp has passed, DynamoDB automatically marks the item as expired and later deletes it in the background. This directly satisfies the requirement because the telemetry is only valuable for a limited time, yet it is currently stored indefinitely.
Enabling TTL (option C) improves performance and operational efficiency by preventing the table from growing without bounds. As the item count grows, access patterns that rely on scans, large partitions, or indexes can degrade, and storage-related overhead increases. TTL helps keep the dataset "fresh" by automatically removing stale telemetry, reducing the amount of data the application must work around and decreasing overall storage footprint.
Option A is operationally heavier: scanning and deleting items with a scheduled Lambda introduces ongoing maintenance, costs, and risk of throttling (table scans can be expensive and disruptive). It also requires custom logic, error handling, and retries. Option B addresses cost optimization for archived data but does not fix the DynamoDB table size or the performance degradation caused by keeping old data in the table; archiving is useful, but you still need an efficient deletion mechanism from DynamoDB. Option D (on-demand capacity mode) changes how capacity is managed, not how much data is stored; it does not remove stale items and therefore does not address the core problem.
Therefore, the best and most operationally efficient solution is C: add a TTL attribute to each telemetry item and enable TTL on the DynamoDB table so DynamoDB automatically expires and deletes old telemetry.

* Option B: The target group port in the ALB must match the port specified in the ECS task definition. If there is a mismatch, the ALB health check will fail since it cannot correctly route traffic to the container.
* Option E: The ALB listener must have a default action that forwards requests to the correct target group associated with the ECS service. If this configuration is missing, the health check will fail as no traffic is routed to the service.
* Option A is irrelevant to resolving health check issues since capacity providers relate to provisioning compute capacity.
* Option C (hosted zone) is not directly related to ALB health checks.
* Option D (redirecting traffic) is not related to ECS health check configurations.
Reference:AWS ECS Health Check Documentation

HTTP 429 errors indicate throttling ("Too Many Requests"). In this architecture, throttling can occur at multiple layers (API Gateway rate limits, downstream AWS service API throttles, or dependency throttling).
Regardless of which service is throttling, the correct resilience pattern is to implement retries with exponential backoff and jitter for retryable failures. AWS SDKs and AWS best practices recommend backoff to reduce contention and allow the system to recover, while ensuring requests eventually succeed.
Option C directly addresses the problem and the requirement "ensure that all of the application ingests all files." With a retry + backoff pattern, transient throttling is handled gracefully: failed operations are retried after increasing delays, avoiding immediate retry storms that worsen throttling. This increases successful completion rate without requiring major architectural changes.
Option A (Transfer Acceleration) can improve upload latency from geographically distributed clients, but it does not resolve request throttling (429) caused by API limits.
Option B (multipart upload) helps with large object uploads and can improve throughput/reliability for big files, but it does not inherently prevent 429 throttling at API Gateway or other throttled calls.
Option D (Intelligent-Tiering) affects storage cost optimization, not ingestion throttling.