High Availability practice questions

AWS Backup Vault Lock

Why wrong: Backup Vault Lock protects backups, not CloudFront delivery.

IAM Access Analyzer

Why wrong: Access Analyzer reviews permissions and does not serve cached content.

S3 Select

Why wrong: S3 Select retrieves subsets of object data and does not increase origin outage tolerance.

S3 Cross-Region Replication

Why wrong: S3 CRR applies to S3 objects, not RDS failover.

Read replicas only

Why wrong: Read replicas improve read scalability and can support DR, but they are not the primary automatic AZ failover feature.

EBS snapshots every hour

Why wrong: Snapshots help recovery but do not provide automatic high availability.

AWS Backup Vault Lock

Why wrong: Backup Vault Lock protects backups, not CloudFront delivery.

IAM Access Analyzer

Why wrong: Access Analyzer reviews permissions and does not serve cached content.

S3 Select

Why wrong: S3 Select retrieves subsets of object data and does not increase origin outage tolerance.

S3 Cross-Region Replication

Why wrong: S3 CRR applies to S3 objects, not RDS failover.

Read replicas only

Why wrong: Read replicas improve read scalability and can support DR, but they are not the primary automatic AZ failover feature.

EBS snapshots every hour

Why wrong: Snapshots help recovery but do not provide automatic high availability.

The database remains unavailable until an administrator manually creates a new instance.

Why wrong: Manual recreation is not how Multi-AZ is designed to recover from a primary failure.

Traffic is routed to a read replica in another Region for immediate continuity.

Why wrong: A read replica is not the same as a Multi-AZ standby, and another Region is a disaster recovery pattern.

The failed primary continues serving traffic while the standby synchronizes in the background.

Why wrong: A failed primary cannot continue serving traffic; the standby becomes active after failover.

Increase the instance size so each server can handle more traffic alone.

Why wrong: A larger instance may improve capacity, but it does not protect against an Availability Zone failure. If the Zone goes down, all instances in that Zone are still lost regardless of their size.

Disable ALB health checks so instances stay registered longer.

Why wrong: Health checks are useful for removing unhealthy targets quickly. Disabling them would make failover and recovery worse because the load balancer could keep sending traffic to broken instances.

Run the whole stack in one Availability Zone for simpler networking.

Why wrong: A single Availability Zone creates a clear single point of failure. Simplicity may be appealing, but it does not meet the goal of surviving a Zone outage.

Spread the instances across three Availability Zones for better fault tolerance.

Why wrong: Spreading across AZs improves resilience, but it increases network distance and typically adds latency. The scenario is explicitly about minimizing jitter and latency for frequent east-west traffic within one AZ, so multi-AZ spread is the wrong optimization.

Front the nodes with an Application Load Balancer to balance the internal messages.

Why wrong: An ALB is for HTTP/HTTPS application traffic, not for direct node-to-node messaging performance. It adds a layer that does not solve the underlying east-west latency issue. The workload needs closer physical placement and better networking, not a web load balancer.

Store the messages on EBS volumes so the nodes avoid network communication.

Why wrong: EBS is block storage for persistent data, not a low-latency message bus. Writing messages to disk would add storage latency and does not create efficient inter-node communication. It also changes the workload architecture in an unsupported way for this requirement.

Place the instances in a spread placement group across multiple Availability Zones.

Why wrong: Spread placement groups are designed to reduce correlated failure risk by separating instances, not to minimize communication latency. Spreading instances across multiple AZs adds network distance and is the opposite of what a latency-sensitive clustered workload wants. The design improves resilience, but it sacrifices the fast intra-node communication the application needs.

Place the instances in a partition placement group within one Availability Zone.

Why wrong: Partition placement groups are useful when you want to isolate groups of instances from each other for resilience at large scale. They do not provide the same tight network proximity as a cluster placement group. For a low-latency analytics cluster, partitioning adds unnecessary separation and is not the best choice for fast node-to-node messaging.

Deploy the instances behind an Application Load Balancer in multiple Availability Zones.

Why wrong: An Application Load Balancer helps distribute client traffic for HTTP and HTTPS applications, but it does not optimize the private network path between EC2 instances. Adding multiple Availability Zones also increases the distance between nodes. That helps availability, but it does not address the workload's requirement for very low inter-instance latency.

EC2 Placement Groups with the "spread" strategy

Why wrong: Spread placement groups are designed to reduce the risk of correlated failures by placing instances on distinct underlying hardware (for example, different racks). That separation can increase network latency compared to cluster placement groups, which are optimized for lowest latency.

Auto Scaling cooldown adjustments only

Why wrong: Cooldown controls how quickly Auto Scaling scales in or out after a scaling event. It does not influence where instances are physically placed on the underlying hardware, so it cannot reduce network latency variability between instances.

Switching the instances to a larger instance size without any placement group

Why wrong: Larger instance sizes can improve CPU or networking throughput, but without a placement group you do not get guidance to place the communicating instances close together. Latency variability between instances is therefore not addressed.

Use a spread placement group to distribute instances across distinct hardware to reduce jitter.

Why wrong: Spread placement groups are designed primarily for fault isolation by placing instances across distinct underlying hardware. They do not prioritize the tight placement needed to maximize low-jitter, low-latency networking between all nodes.

Use a partition placement group and place each node into its own partition for uniform latency.

Why wrong: Partition placement groups provide isolation between partitions for very large deployments, limiting blast radius. They are not the best choice for maximizing low-jitter network performance among every node that must communicate constantly within a single AZ.

Do not use a placement group; rely on the default EC2 scheduling to balance latency and availability.

Why wrong: Without a placement group, instance placement is left to default scheduling, which can vary across different underlying hardware. That unpredictability makes it harder to achieve consistently low network jitter for tightly coupled, frequent-message communication.

Disable automated backups to reduce the time needed for failover.

Why wrong: Automated backups do not slow down RDS failover, and disabling them removes point-in-time recovery and other restore options. Backups are a recovery control, not a failover bottleneck.

Use a single-AZ deployment so the standby is not split across Zones.

Why wrong: A single-AZ deployment has no standby instance in another Availability Zone, so it cannot provide automatic failover for an instance or AZ failure. It is less resilient than Multi-AZ.

Replace the database with an Amazon S3 bucket and store rows as objects.

Why wrong: Amazon S3 is object storage, not a relational database engine. It does not provide transactional relational semantics or database-style automatic failover for this workload.

Use a spread placement group to distribute instances across multiple underlying hardware to improve overall availability.

Why wrong: Spread placement groups are optimized for fault isolation across distinct underlying hardware. They intentionally reduce the likelihood of all instances sharing the same failure domain, which typically increases the variability in network paths rather than minimizing latency/jitter between instances.

Use no placement group and rely on the Auto Scaling group to balance instance placement automatically.

Why wrong: Auto Scaling helps with capacity and scaling, but it does not guarantee proximity of instances for low-latency inter-node traffic. Without a placement group, placement is determined by normal scheduling, which may not keep instances close together.

Use a partition placement group so each instance is assigned to separate failure domains for low variance.

Why wrong: Partition placement groups are designed to distribute instances across partitions for capacity scaling with fault isolation (each partition is its own failure domain). They are not intended to keep instances in a tightly coupled network layout, so they do not best satisfy jitter-sensitive, low-latency requirements.

Enable cross-zone load balancing so all targets receive traffic from every AZ.

Why wrong: Enabling cross-zone generally increases cross-AZ traffic and can raise inter-AZ transfer costs.

Move the NLB to a different Region so traffic is always kept local.

Why wrong: Changing Region does not eliminate inter-AZ traffic within the new Region and can add Region transfer costs.

Replace the NLB with a NAT gateway to reduce data charges between AZs.

Why wrong: NAT gateways affect egress to the internet; they do not control inter-AZ routing for load balancer traffic.

Create a read replica in the same Availability Zone as the primary database.

Why wrong: A read replica helps with read scaling and some recovery scenarios, but it does not provide automatic failover like a Multi-AZ deployment.

Increase the backup retention period to 35 days.

Why wrong: Longer backups improve recovery options, but they do not provide automatic failover during an outage. Backups are still a restore-based process.

Move the database to an EC2 instance with an attached EBS volume.

Why wrong: Running the database on EC2 adds operational burden and usually reduces managed failover capability compared with RDS Multi-AZ.

Set the ECS deployment configuration to maximum percent 100 so tasks replace instances faster during rollouts.

Why wrong: Deployment timing can help during releases but does not ensure capacity exists in another AZ during failures.

Enable ALB connection draining longer than expected so existing connections survive longer during an AZ event.

Why wrong: Connection draining affects in-flight sessions but does not restore capacity for new requests after AZ loss.

Reduce task memory reservations to pack both tasks onto a single EC2 instance.

Why wrong: Packing tasks onto fewer instances increases blast radius; it does not improve multi-AZ resilience.

Use a single EBS Multi-Attach volume mounted read/write by all instances across AZs.

Why wrong: EBS Multi-Attach is not a general-purpose multi-AZ shared filesystem for application servers. It has service limitations and is not the correct service for many instances requiring concurrent shared file access across AZs. EFS is the AWS-managed option designed for this use case.

Store the files in S3 and mount them directly through the console as a shared network filesystem.

Why wrong: S3 is object storage, not a native shared filesystem with standard POSIX semantics. It does not provide the same low-latency metadata behavior or filesystem-level concurrent read/write model that application servers expect. This option does not satisfy the workload requirements.

Place the files on instance store volumes so each server has faster local access.

Why wrong: Instance store is local to a single EC2 instance and is ephemeral. That means each server would have its own isolated copy of the data, which breaks the requirement for a shared filesystem across multiple instances. It also risks data loss if an instance stops or terminates.

Create a placement group with the 'spread' strategy to separate instances across underlying hardware for fault tolerance.

Why wrong: Spread placement groups are designed for high availability by distributing instances across distinct underlying hardware. This does not specifically optimize for low latency between instances, and it may increase network variability for synchronization-heavy workloads.

Use the default placement strategy and rely on Auto Scaling to keep instances from drifting to different locations.

Why wrong: The default strategy does not guarantee physical co-location for low-latency networking. Auto Scaling changes the set of running instances over time and can introduce placement variation, so it cannot reliably eliminate network latency spikes caused by instance placement.

Avoid placement groups and instead use Amazon S3 for inter-node messaging to minimize direct network traffic between instances.

Why wrong: S3 is not designed for low-latency synchronization traffic between tightly coupled nodes. Using S3 introduces object storage semantics and higher request/processing latency compared to direct instance-to-instance networking in a cluster placement group.

Create a weighted record set that sends 50 percent of traffic to each Region.

Why wrong: Weighted routing is useful for splitting traffic or testing, but it does not provide the strict primary-versus-secondary behavior required for automatic failover.

Create a latency-based record set so Route 53 always prefers the fastest Region.

Why wrong: Latency-based routing chooses the nearest or fastest endpoint for each client request. That is different from a deliberate active-passive design where one Region is primary and another is only used when the primary fails.

Create a multivalue answer record to return both ALB addresses on each lookup.

Why wrong: Multivalue answers can improve availability by returning multiple healthy values, but they do not implement the explicit primary-to-secondary failover pattern described in the scenario.

Partition placement group

Why wrong: Partition PGs distribute instances across separate hardware racks to reduce rack-failure impact. This increases inter-node distance and latency. Designed for distributed databases (Hadoop, Kafka), not tightly coupled HPC.

Spread placement group

Why wrong: Spread PGs place each instance on distinct hardware racks for maximum isolation. This increases inter-node distance — the opposite of what HPC requiring low latency needs.

No placement group — use Auto Scaling across multiple AZs

Why wrong: Cross-AZ Auto Scaling distributes instances for availability but increases inter-node latency. HPC requiring sub-microsecond inter-node communication needs all instances in one AZ within a Cluster PG.

S3 Cross-Region Replication

Why wrong: S3 CRR applies to S3 objects, not RDS failover.

EBS snapshots every hour

Why wrong: Snapshots help recovery but do not provide automatic high availability.

Read replicas only

Why wrong: Read replicas improve read scalability and can support DR, but they are not the primary automatic AZ failover feature.