Skip to content

SAP-C03 · Domain 1: Architecture Design and Implementation Built for the Cloud · 25% of the exam

Task 1.5: Design data, storage, and database architectures.

Data where it fits: data lakes and lakehouses, streaming and batch analytics, choosing a database for access pattern, consistency and scale, replicas and global databases, storage chosen for performance, caching, and cataloging and sharing data across accounts.

Study it

Sample questions

Try each one before opening the answer. Every option is explained, with the AWS documentation page that proves it.

Question 1 · choose 1

A reporting application uses Amazon RDS for PostgreSQL. During business hours, read-only dashboard queries keep CPU above 90%, and the writes of the order service slow down. The instance already uses the largest class the company will pay for. The dashboards can read data that is a few seconds old and can use their own connection string. Which change solves the problem?

  1. APut Amazon RDS Proxy in front of the database and point the dashboards at the proxy endpoint
  2. BAdd read replicas and point the dashboards at them, adding more replicas as dashboard use grows
  3. CConvert the instance to a Multi-AZ DB instance deployment and send the dashboard queries to the standby
  4. DChange the instance to the next larger instance class during business hours and back again at night
Show the answer and why
  • APut Amazon RDS Proxy in front of the database and point the dashboards at the proxy endpoint

    Incorrect

    RDS Proxy pools and shares connections. The dashboard queries would still run on the same instance and use the same CPU.

  • BAdd read replicas and point the dashboards at them, adding more replicas as dashboard use grows

    Correct

    Read replicas take read-only queries off the primary instance and use asynchronous replication, which matches dashboards that accept a few seconds of lag. Scaling out with more replicas avoids a larger class.

  • CConvert the instance to a Multi-AZ DB instance deployment and send the dashboard queries to the standby

    Incorrect

    In a Multi-AZ DB instance deployment the standby does not serve read traffic; it exists for failover.

  • DChange the instance to the next larger instance class during business hours and back again at night

    Incorrect

    This is scaling up, which the company has ruled out on cost, and a class change can cause downtime while the instance reboots.

When scaling up has reached its limit and the load is read-only, scale out with read replicas.

Question 2 · choose 1

A data platform account holds a data lake in Amazon S3 that is cataloged in the AWS Glue Data Catalog. Analysts in 30 other accounts of the same organization query it with Amazon Athena from their own accounts. Today each team receives a replicated copy of the S3 data it needs. A new governance standard requires that the data is not duplicated anywhere, that access follows classification labels that data stewards assign to databases, tables and individual columns, that a table classified later reaches the right teams without any new grant, and that each consumer account's own data lake administrator decides which of its users get the shared data. Which solution meets these requirements?

  1. AKeep replicating the S3 data into a bucket in each consumer account and have every account catalog its copy with its own Glue crawler
  2. BGrant the consumer accounts access to the tables in a Data Catalog resource policy and to the data prefixes in the S3 bucket policy
  3. CLoad the tables into an Amazon Redshift cluster in the platform account and share them with each consumer account through Redshift datashares
  4. DRegister the S3 locations with Lake Formation, assign LF-Tags to the catalog resources, and grant tag-based permissions to the accounts
Show the answer and why
  • AKeep replicating the S3 data into a bucket in each consumer account and have every account catalog its copy with its own Glue crawler

    Incorrect

    S3 Replication copies objects asynchronously into other buckets, including buckets owned by other accounts, so every consumer account would keep its own duplicate of the data, which the standard forbids.

  • BGrant the consumer accounts access to the tables in a Data Catalog resource policy and to the data prefixes in the S3 bucket policy

    Incorrect

    Catalog resource policies and bucket policies grant access to named Data Catalog resources and S3 objects. The grants do not follow classification labels or reach individual columns, and every newly classified table would mean editing both policies.

  • CLoad the tables into an Amazon Redshift cluster in the platform account and share them with each consumer account through Redshift datashares

    Incorrect

    Datashares give other accounts live access without copying data between warehouses, but loading the lake with COPY puts a second copy of the data into Redshift tables, and the analysts would no longer query the lake with Athena.

  • DRegister the S3 locations with Lake Formation, assign LF-Tags to the catalog resources, and grant tag-based permissions to the accounts

    Correct

    LF-Tags can be assigned to databases, tables and columns, and a grant on an LF-Tag expression covers every resource with a matching tag, including tables tagged later. Cross-account grants keep the data in place, the consumer's data lake administrator grants the shared data to its own principals, and Athena queries it through resource links.

The constraints are no duplicate data, access by classification down to the column, automatic coverage of newly classified tables, and consumer-side control of who sees the shared data. Replication duplicates the lake, Redshift loading duplicates it too, and catalog and bucket policies grant access by resource name rather than by label. Lake Formation tag-based access control shares the catalog resources across accounts by LF-Tag, and each consumer's data lake administrator grants them on to its own analysts.

Question 3 · choose 1

A retailer and a consumer goods brand want to measure how many people who saw the brand's ads later bought its products at the retailer. Each company keeps its customer data in Amazon S3 in its own AWS account, cataloged in AWS Glue. Neither company may see the other's row-level records, the retailer requires every result row to aggregate at least 100 distinct customers, and the data must stay where it is instead of being copied to the other party. Which solution meets these requirements?

  1. AGrant the brand's account access to the retailer's tables through Lake Formation cross-account permissions with column filters
  2. BUse an AWS Clean Rooms collaboration with aggregation analysis rules and an output constraint of 100 customers
  3. CLoad both datasets into Amazon Redshift and share the combined tables with the brand through a datashare
  4. DExport hashed customer lists to a shared S3 bucket and have each company join them with Amazon Athena
Show the answer and why
  • AGrant the brand's account access to the retailer's tables through Lake Formation cross-account permissions with column filters

    Incorrect

    Lake Formation cross-account sharing lets the brand query the shared table directly, so it would see the retailer's row-level records.

  • BUse an AWS Clean Rooms collaboration with aggregation analysis rules and an output constraint of 100 customers

    Correct

    Clean Rooms reads each member's data in place and enforces each table's analysis rules. An aggregation rule with an output constraint returns only result rows that cover at least the required number of distinct identifier values.

  • CLoad both datasets into Amazon Redshift and share the combined tables with the brand through a datashare

    Incorrect

    This copies the retailer's data into a shared warehouse and gives the brand live read access to the shared tables, including row-level data.

  • DExport hashed customer lists to a shared S3 bucket and have each company join them with Amazon Athena

    Incorrect

    Both companies would copy row-level data into a bucket the other can read, and nothing enforces the minimum of 100 customers per row.

Joint analysis without revealing underlying records is the purpose of AWS Clean Rooms: data stays in each owner's account, and analysis rules such as aggregation output constraints control what any query can return.

Question 4 · choose 1

A gaming company is building a player profile service on Amazon DynamoDB in us-east-1 and eu-west-1. Players in each Region must write with single-digit millisecond latency to their nearest Region, and if one Region fails, the other must already have the data and keep accepting writes. The company accepts that the last write wins when the same item is changed in both Regions at once. Which solution meets these requirements?

  1. ACreate a DynamoDB global table with replicas in both Regions in multi-Region eventual consistency mode
  2. BCopy backups of the table to the other Region every hour with AWS Backup and restore them if a Region fails
  3. CWrite to a table in us-east-1 only and add DynamoDB Accelerator clusters in eu-west-1 for European players
  4. DMigrate the profiles to an Aurora global database with its primary cluster in us-east-1
Show the answer and why
  • ACreate a DynamoDB global table with replicas in both Regions in multi-Region eventual consistency mode

    Correct

    Global tables replicate writes between Regions in which every replica accepts reads and writes. In multi-Region eventual consistency mode, conflicting concurrent writes are resolved with last writer wins.

  • BCopy backups of the table to the other Region every hour with AWS Backup and restore them if a Region fails

    Incorrect

    Restored backups lose the changes made since the last backup and take time to restore, so the other Region would not already have the data.

  • CWrite to a table in us-east-1 only and add DynamoDB Accelerator clusters in eu-west-1 for European players

    Incorrect

    DAX is an in-memory cache for a table in its own Region. European writes would still travel to us-east-1, and nothing would take writes if that Region failed.

  • DMigrate the profiles to an Aurora global database with its primary cluster in us-east-1

    Incorrect

    An Aurora global database accepts writes in its primary Region. Players near the secondary Region would not get local writes.

Local writes in two Regions with last-writer-wins conflict handling is the default mode of DynamoDB global tables.

Question 5 · choose 1

A product catalog service stores items in Amazon DynamoDB. The same popular items are read millions of times per hour, and the new mobile app needs microsecond read latency for them. The developers want to keep using the DynamoDB API and avoid writing cache invalidation logic. Which solution meets these requirements?

  1. ASwitch the table to on-demand capacity mode so that reads are never throttled
  2. BAdd a global table replica in every Region where the mobile app has users
  3. CPut an Amazon ElastiCache cluster in front of the table and write the caching logic into the service
  4. DAdd a DynamoDB Accelerator (DAX) cluster and switch the service to the DAX client
Show the answer and why
  • ASwitch the table to on-demand capacity mode so that reads are never throttled

    Incorrect

    On-demand mode changes how throughput is billed and scaled. Reads still come from DynamoDB with single-digit millisecond latency, not microseconds.

  • BAdd a global table replica in every Region where the mobile app has users

    Incorrect

    Replicas bring data closer to users, but each read is still a DynamoDB read in milliseconds.

  • CPut an Amazon ElastiCache cluster in front of the table and write the caching logic into the service

    Incorrect

    This can reach microsecond reads, but the developers would write and maintain the caching and invalidation code that they want to avoid.

  • DAdd a DynamoDB Accelerator (DAX) cluster and switch the service to the DAX client

    Correct

    DAX is a DynamoDB-compatible in-memory cache that delivers microsecond reads for cached items, and it works with existing DynamoDB API calls, so the application does not manage cache data itself.

Microseconds on top of DynamoDB with the same API is DAX; ElastiCache works but brings its own cache code.

Question 6 · choose 3

A company is designing a tightly coupled computational fluid dynamics workload that runs on hundreds of Amazon EC2 instances. The nodes exchange messages constantly with MPI, and all nodes read the same large input data set at hundreds of GB/s. Which design choices give the best performance? (Choose THREE.)

  1. ALaunch the instances in a spread placement group so that each one runs on separate hardware
  2. BLaunch the instances in a cluster placement group in one Availability Zone
  3. CAttach an Elastic Fabric Adapter to each instance for the MPI traffic
  4. DSpread the instances across three Availability Zones with an Auto Scaling group
  5. EStore the input data on Amazon FSx for Lustre linked to the S3 bucket that holds it
  6. FUse burstable T instances to cut cost when the solver is idle between time steps
Show the answer and why
  • ALaunch the instances in a spread placement group so that each one runs on separate hardware

    Incorrect

    A spread placement group places instances on distinct hardware to limit correlated failures. It does not give the low-latency network that tightly coupled jobs need.

  • BLaunch the instances in a cluster placement group in one Availability Zone

    Correct

    A cluster placement group packs instances close together inside one Availability Zone for low-latency, high-throughput networking between nodes.

  • CAttach an Elastic Fabric Adapter to each instance for the MPI traffic

    Correct

    An Elastic Fabric Adapter lets HPC applications that use MPI communicate between instances with lower latency and higher throughput than standard TCP networking.

  • DSpread the instances across three Availability Zones with an Auto Scaling group

    Incorrect

    Spreading nodes across zones adds latency between them, which slows a job where nodes exchange messages constantly.

  • EStore the input data on Amazon FSx for Lustre linked to the S3 bucket that holds it

    Correct

    FSx for Lustre is a high-performance file system with sub-millisecond latencies and up to multiple TBps of throughput, and it can be linked to a data repository on Amazon S3.

  • FUse burstable T instances to cut cost when the solver is idle between time steps

    Incorrect

    Burstable instances give a baseline CPU level with short bursts, which does not suit sustained, compute-heavy solver runs.

Tightly coupled HPC needs nodes close together, a low-latency fabric and a parallel file system: cluster placement group, EFA and FSx for Lustre.

Question 7 · choose 2

A new analytics design keeps 50 TB of clickstream data in S3 as uncompressed CSV files under one prefix, and a new file lands every hour. Analysts run ad hoc Athena queries; each filters on a different date range and reads 5 of the 80 columns. Queries are slow, and per-query scan charges are high. The team must keep using Athena, must cut the amount of data each query reads, and wants new hourly data to be queryable without anyone running a crawler or adding partitions by hand. Which changes meet these requirements? (Choose TWO.)

  1. ACreate an Athena capacity reservation and assign the analysts' workgroup to it so that their queries run on dedicated capacity
  2. BSplit the hourly CSV files into many files of about 1 MB each so that Athena can read more of them in parallel
  3. CConvert the data to a columnar format such as Apache Parquet with appropriately large files
  4. DPartition the data by date and configure partition projection on the table for the date partition key
  5. ETurn on query result reuse for the workgroup so that Athena returns stored results instead of scanning the data again
Show the answer and why
  • ACreate an Athena capacity reservation and assign the analysts' workgroup to it so that their queries run on dedicated capacity

    Incorrect

    Capacity reservations give dedicated serverless processing capacity and let you prioritize workgroups and control how they are billed. Queries on reserved capacity still read every byte of the CSV files they touch.

  • BSplit the hourly CSV files into many files of about 1 MB each so that Athena can read more of them in parallel

    Incorrect

    AWS advises against datasets with many small files: Athena lists every location and pays an overhead for each file, which makes queries slower, and the queries still read all 80 columns.

  • CConvert the data to a columnar format such as Apache Parquet with appropriately large files

    Correct

    Columnar formats let Athena read only the columns a query needs and use file metadata to skip unneeded parts of the data, so reading 5 of 80 columns scans a small fraction of the data.

  • DPartition the data by date and configure partition projection on the table for the date partition key

    Correct

    Partitioning restricts each query to the matching dates. With partition projection, Athena calculates partition values and locations from table properties, which automates partition management, so new hours need no crawler or manual partition updates.

  • ETurn on query result reuse for the workgroup so that Athena returns stored results instead of scanning the data again

    Incorrect

    Result reuse returns the stored result of a previous matching query, which helps when the same query is rerun. These ad hoc queries each use a different date range, so there is nothing to reuse.

The deciding constraints are fewer bytes read per query, staying on Athena, and no manual partition maintenance. Capacity reservations and result reuse change how queries run or are billed, not what a new query scans, and many small files make Athena slower. Parquet cuts the columns read, and date partitions with partition projection cut the rows read while new hours become queryable automatically.

Question 8 · choose 1

A new DynamoDB orders table uses order ID as its partition key. A new screen must list a customer's orders by date, and today the application scans the whole table to do so. Which change fits?

  1. AAdd a DAX cluster in front of the table
  2. BIncrease the table's read capacity
  3. CAdd a global secondary index on customer ID and order date
  4. DExport the table to S3 every night and query it with Athena
Show the answer and why
  • AAdd a DAX cluster in front of the table

    Incorrect

    DAX caches reads but does not avoid scanning for a new access pattern.

  • BIncrease the table's read capacity

    Incorrect

    More capacity makes scans cost more; they still read the whole table.

  • CAdd a global secondary index on customer ID and order date

    Correct

    Global secondary indexes support queries on different attributes than the table's key.

  • DExport the table to S3 every night and query it with Athena

    Incorrect

    Nightly exports are a day old and slow for an interactive screen.

New access patterns on DynamoDB are served by global secondary indexes.

Question 9 · choose 1

A fraud team runs 12 stateful Apache Flink jobs written in Java on a self-managed cluster. The jobs read card transactions from Kafka, keep per-card state in event-time windows, and must score each transaction within a second. As part of the migration, the company wants to keep the Flink code with only connector and configuration changes, keep checkpoint-based recovery of job state, and stop provisioning, scaling and patching any processing cluster. Which target architecture meets these requirements?

  1. ARun the jobs as applications in Amazon Managed Service for Apache Flink, reading from the migrated Kafka topics
  2. BRun the jobs on a long-running Amazon EMR cluster that hosts Flink as a YARN application
  3. CRewrite the jobs as AWS Glue streaming ETL jobs that read the Kafka topics with Spark Structured Streaming
  4. DSend the transactions to Amazon Data Firehose and score them with a transformation Lambda function before delivery
Show the answer and why
  • ARun the jobs as applications in Amazon Managed Service for Apache Flink, reading from the migrated Kafka topics

    Correct

    Managed Service for Apache Flink runs Flink applications written in Java and other languages and provides the infrastructure: it provisions compute, scales automatically, handles Availability Zone failover, and backs up application state with checkpoints and snapshots.

  • BRun the jobs on a long-running Amazon EMR cluster that hosts Flink as a YARN application

    Incorrect

    EMR supports Flink as a YARN application, so the code can stay as it is, but the team would still size, scale and maintain the EMR cluster that the jobs run on.

  • CRewrite the jobs as AWS Glue streaming ETL jobs that read the Kafka topics with Spark Structured Streaming

    Incorrect

    Glue streaming jobs are serverless, but they run on the Apache Spark Structured Streaming engine, so every Flink job would have to be rewritten.

  • DSend the transactions to Amazon Data Firehose and score them with a transformation Lambda function before delivery

    Incorrect

    Firehose is a fully managed service for delivering streaming data to destinations such as S3 and Redshift. It does not run Flink code or keep per-card state across events, so the jobs would be rebuilt without their windows.

The constraints are unchanged Flink code, managed state recovery, sub-second scoring and no cluster to operate. EMR keeps the code but not the operations savings, Glue requires a Spark rewrite, and Firehose delivers data rather than running stateful jobs. Managed Service for Apache Flink runs the existing applications with managed checkpoints, snapshots and scaling.

Practice domain 1 →Practice all domains →