SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
DEA-C01 · Domain 2

Data Store Management practice questions

Data Store Management is worth 26% of the DEA-C01 exam — the 2nd-heaviest of the 4 domains. Choosing and configuring data stores, cataloging data, managing data lifecycle, and designing data models with schema evolution. Official weighting 26%. 6 fully worked examples are further down this page, answers included.

Exam weight
26%
the 2nd-heaviest of the 4 domains
Questions
176
across 4 topics
Free, no account
5/day
a free account allows 10 a day
Explanations
Every option
right and wrong

Build a practice session

5 free questions left today.

Domains

How many?

5 free questions left today.

Mode

Ready when you are

10 fresh questions drawn across 1 of 4 domains, in Learn mode.

Review what you missed

Every question you answer incorrectly, and every question you flag while practising, is saved here automatically. Finish a session and you can come back to re-drill just those.

6 sample Data Store Management questions, fully explained

Questions from the DEA-C01 bank mapped to domain 2, with the answer key and the reasoning behind every option. None of them repeat the examples on the main DEA-C01 practice page.

Question 1Data Store Management

A startup runs analytics that sit idle for most of the day, then spike without warning when analysts explore new datasets, sometimes at night or on weekends. The team does not want to size or operate a cluster, and it wants to pay only for the compute its queries actually consume. Which Amazon Redshift configuration meets these requirements?

Choose one.

  • a
    A Redshift Serverless workgroup with an RPU reservation

    Serverless reservations commit to a number of RPUs for a one-year term and are billed every hour whether or not queries run, so idle time is still paid for, the opposite of paying only for consumed compute.

  • b
    A provisioned cluster with concurrency scaling turned on

    Concurrency scaling bursts capacity during peaks, but the base cluster is still sized, operated and billed while idle.

  • c
    A provisioned cluster on a scheduled pause and resume plan

    Pausing stops compute billing, but a schedule cannot predict spikes that arrive without warning; queries during a paused window fail until someone resumes the cluster, and the team still sizes and operates it.

  • d
    A Redshift Serverless workgroup with a base RPU capacity Correct

    Correct. Redshift Serverless has no cluster to size or manage, scales compute automatically when queries arrive, and bills in RPU-seconds only while queries run, so idle periods cost nothing for compute.

The concept

Redshift Serverless bills for compute only while queries run and scales automatically; provisioned clusters, even with pause/resume or concurrency scaling, are sized and operated by you.

Why that’s the answer

Two constraints decide: unpredictable, intermittent load and pay-per-use with no cluster to operate. Serverless on-demand billing meets both. A pause/resume schedule is the tempting near-twin because it also avoids paying for idle compute, but it only works when idle periods are predictable, and the cluster is still yours to size. A Serverless reservation keeps the no-cluster model but bills its committed RPUs every hour, idle or not. Concurrency scaling optimizes an always-on provisioned cluster.

How to reason it out
  1. Note the load profile: mostly idle, unpredictable spikes.
  2. Note the operations constraint: no cluster to size or manage.
  3. Reject provisioned options, including scheduled pause, which needs predictable idle windows.
  4. Reject commitments such as reservations that bill whether or not queries run.
  5. Choose Redshift Serverless on-demand, billed per RPU-second while queries run.

Exam tip: Intermittent, unpredictable analytics with no cluster to manage means Redshift Serverless.

Choosing an AWS Data Store: Redshift, DynamoDB, Aurora, S3, and MemoryDB — the lesson that teaches this.

Question 2Data Store Management

A company keeps 500 TB of historical clickstream data as Apache Parquet in Amazon S3, with table definitions in the AWS Glue Data Catalog. Analysts on an Amazon Redshift cluster need to join this history with warehouse tables a few times a month. Loading the history into the cluster is too costly. What is the most cost-effective way for the analysts to run these joins?

Choose one.

  • a
    Define a federated query external schema over the S3 bucket

    Federated queries connect Redshift to live RDS and Aurora databases (PostgreSQL and MySQL engines). They do not read files in S3.

  • b
    Load the needed months into temporary tables with COPY beforehand

    COPY moves the data into cluster storage before each analysis, adding load time and storage for data that is queried only a few times a month.

  • c
    Run AWS Glue jobs that load the history into Redshift tables

    This is still loading the history into the cluster, the cost the stem rules out, and it adds a pipeline to maintain.

  • d
    Define a Spectrum external schema and query the files in place Correct

    Correct. Redshift Spectrum queries the Parquet files in place through an external schema that references the Glue Data Catalog, charges by data scanned, and joins the results with local tables in one SQL statement.

The concept

Redshift Spectrum queries data in S3 in place through external tables in an external schema (usually backed by the AWS Glue Data Catalog), so cold history never has to be loaded into the cluster.

Why that’s the answer

The data lives in S3, is huge, and is queried occasionally, so the answer is to query it in place. Spectrum does this and bills by bytes scanned, which Parquet and partitioning keep low. Federated queries are the near-twin people confuse with Spectrum, but they target live RDS and Aurora databases, not S3 files. COPY and Glue loads both put the data into the cluster.

How to reason it out
  1. Locate the data: Parquet files in S3, already cataloged.
  2. Note the constraint: do not load it into Redshift.
  3. Match S3-in-place querying from Redshift to Spectrum, not to federated queries.
  4. Create an external schema from the Data Catalog and join external with local tables.

Exam tip: S3 files from Redshift without loading = Spectrum; live RDS/Aurora rows from Redshift = federated query.

Choosing an AWS Data Store: Redshift, DynamoDB, Aurora, S3, and MemoryDB — the lesson that teaches this.

Question 3Data Store Management

A reporting team on Amazon Redshift needs to join warehouse history with current order status from the production Amazon Aurora PostgreSQL database. Results must reflect the order table as it is at query time. The data governance team requires that order data is not replicated or stored in Redshift, and the team does not want to build a pipeline. What should the team set up?

Choose one.

  • a
    A Spectrum external schema that reads the Aurora order tables

    Spectrum reads files in S3 through external tables. It cannot query a running Aurora database.

  • b
    An Aurora zero-ETL integration that feeds the Redshift cluster

    Zero-ETL needs no pipeline and is close to real time, but it replicates the Aurora tables into Redshift storage, which the governance requirement forbids.

  • c
    An external schema FROM POSTGRES for Redshift federated queries Correct

    Correct. A federated query external schema points Redshift at the Aurora PostgreSQL endpoint (credentials in Secrets Manager); queries read the live rows at run time, push predicates down, and store nothing in Redshift.

  • d
    Scheduled COPY jobs that load the Aurora snapshot exports from S3

    Snapshot exports are point-in-time copies loaded into Redshift: the data is stale between runs and is stored in the cluster, breaking both requirements.

The concept

Federated queries let Redshift query live data in RDS and Aurora (PostgreSQL and MySQL) at query time without moving it; zero-ETL integrations and COPY loads replicate data into Redshift instead.

Why that’s the answer

Two requirements decide: current data at query time and no copy in Redshift. A federated external schema reads Aurora directly when the query runs and stores nothing. Zero-ETL is the strong near-twin: it is pipeline-free and near real time, but it replicates the data into Redshift. Spectrum reads S3 only, and snapshot exports are stale copies.

How to reason it out
  1. Note where the data lives: a running Aurora PostgreSQL database.
  2. Note the freshness requirement: as of query time.
  3. Apply the governance constraint: no replica in Redshift, which rules out zero-ETL and COPY.
  4. Choose a federated query external schema (CREATE EXTERNAL SCHEMA ... FROM POSTGRES).

Exam tip: Live operational rows, no copy in the warehouse: Redshift federated query. Replica allowed, no pipeline: zero-ETL.

Choosing an AWS Data Store: Redshift, DynamoDB, Aurora, S3, and MemoryDB — the lesson that teaches this.

Question 4Data Store Management

A BI dashboard runs the same expensive Amazon Redshift query every few minutes: a five-table join with heavy aggregation. The underlying tables change only a few times per hour, and dashboard users accept results up to a few minutes old. Load times are poor. Which approach improves dashboard performance with the least ongoing effort?

Choose one.

  • a
    Create a regular view that wraps the five-table join query

    A regular view stores only the query text. Every dashboard refresh still runs the full join and aggregation, so performance does not change.

  • b
    UNLOAD the results hourly to S3 and read them with Spectrum

    This precomputes the result, but you must schedule and monitor the export, the data can be up to an hour old, and the dashboard reads S3 instead of local storage.

  • c
    Create a materialized view on the query with AUTO REFRESH YES Correct

    Correct. The materialized view stores the precomputed join and aggregation in Redshift, refreshes incrementally where possible when base tables change, and automatic query rewrite can serve eligible dashboard queries from it.

  • d
    Turn on concurrency scaling for the dashboard queue in WLM

    Concurrency scaling adds capacity when queries queue; each dashboard query still recomputes the expensive join and aggregation, so individual load times stay poor.

The concept

A Redshift materialized view stores a precomputed query result; with auto refresh (incremental where possible) and automatic query rewrite, repeated expensive aggregations become cheap reads.

Why that’s the answer

The query is the same each time, its inputs change rarely, and slightly stale results are acceptable. That is the materialized view use case: compute once, refresh as data changes, read many times. A regular view recomputes everything. An UNLOAD export precomputes too, but it is a process to run and is staler. Concurrency scaling addresses queueing, not the cost of the query itself.

How to reason it out
  1. Spot the repetition: the same expensive query runs every few minutes.
  2. Check the freshness tolerance: minutes-old results are acceptable and base tables change rarely.
  3. Prefer a managed precomputation inside Redshift over a hand-built export.
  4. Create a materialized view with AUTO REFRESH YES.

Exam tip: Same expensive aggregation, repeated, slowly changing inputs: a materialized view with auto refresh.

Choosing an AWS Data Store: Redshift, DynamoDB, Aurora, S3, and MemoryDB — the lesson that teaches this.

Question 5Data Store Management

A gaming company is building a real-time leaderboard that needs microsecond reads and Redis-compatible sorted sets. The in-memory store will be the only database for the leaderboard. If a node fails, no score update that the application has already been told is saved may be lost. Which service should the company choose?

Choose one.

  • a
    Amazon ElastiCache for Valkey with Multi-AZ replicas

    ElastiCache supports sorted sets and fails over to a replica, but replication is asynchronous: updates acknowledged just before a primary fails can be lost. It is designed as a cache in front of a system of record.

  • b
    Amazon DynamoDB with a DAX cluster in front of the table

    DAX gives microsecond reads from cache for the DynamoDB API, and DynamoDB is durable, but there are no Redis-compatible sorted sets; ranking would have to be rebuilt with indexes and queries.

  • c
    Amazon MemoryDB with Multi-AZ replicas in each shard Correct

    Correct. MemoryDB is Valkey- and Redis OSS-compatible, serves reads in microseconds, and commits every write to a Multi-AZ transaction log before acknowledging it, so it can be the durable primary database.

  • d
    Amazon ElastiCache Serverless for Valkey with snapshots

    Serverless removes node management and snapshots give point-in-time backups, but writes made after the last snapshot can still be lost; it does not durably log every acknowledged write.

The concept

Amazon MemoryDB is a durable in-memory database: Valkey/Redis compatibility and microsecond reads, with every write committed to a Multi-AZ transaction log before it is acknowledged.

Why that’s the answer

The deciding fact is durability of acknowledged writes in an in-memory primary store. ElastiCache replicates asynchronously and snapshots are periodic, so both can lose acknowledged updates; it is meant to sit in front of another database. DAX is durable underneath but does not offer Redis data structures. MemoryDB combines Redis-compatible structures, microsecond reads and a durable Multi-AZ transaction log.

How to reason it out
  1. List the needs: microsecond reads, Redis sorted sets, in-memory store as the only database.
  2. Apply the durability requirement: no loss of acknowledged writes on node failure.
  3. Reject caches with asynchronous replication or periodic snapshots, and DAX, which lacks Redis structures.
  4. Choose MemoryDB.

Exam tip: Redis-compatible and in-memory as the system of record (durable writes): MemoryDB; as a cache in front of a database: ElastiCache.

Choosing an AWS Data Store: Redshift, DynamoDB, Aurora, S3, and MemoryDB — the lesson that teaches this.

Question 6Data Store Management

A team stores product embeddings in Amazon Aurora PostgreSQL with the pgvector extension for semantic search. New products are inserted continuously throughout the day, and the catalog grows by about 20% a month. Searches must return highly accurate nearest neighbors with low latency, and the team can provision extra memory for the index. Which indexing approach best fits?

Choose one.

  • a
    An HNSW index on the embedding column Correct

    Correct. HNSW builds a multi-layer graph that gives high recall with fast queries, can be built on an empty table and updated incrementally as rows arrive. Its costs, more memory and longer builds, are the ones the team can accept.

  • b
    An IVFFlat index built once on the loaded data

    IVFFlat clusters vectors into lists computed from the data present at build time. With continuous inserts and 20% monthly growth, those lists drift from the data and recall degrades unless the index is rebuilt.

  • c
    An IVFFlat index with probes raised per query

    Raising probes improves IVF recall but searches more lists per query, trading latency for accuracy. It does not fix list centers that no longer match a growing dataset.

  • d
    Exact nearest-neighbor search with no index

    A sequential scan returns exact results, but its latency grows with the table and cannot meet a low-latency requirement on a large, growing catalog.

The concept

pgvector on Aurora PostgreSQL offers HNSW and IVFFlat approximate-nearest-neighbor indexes. HNSW: high recall and fast queries, incremental updates, more memory and build time. IVF: faster, cheaper builds on already-loaded data, recall tuned by probes.

Why that’s the answer

Two facts combine. HNSW gives the best recall/latency trade-off and handles continuous inserts because it is updated incrementally. IVFFlat derives its lists from the data at build time, so a fast-growing table needs rebuilds, and raising probes buys recall with latency. Exact search is accurate but slow. The team has accepted HNSW's cost, extra memory.

How to reason it out
  1. Note the query priorities: high recall and low latency.
  2. Note the data behaviour: continuous inserts and steady growth.
  3. Recall that IVF lists come from data present at build time and that probes trade latency for recall.
  4. Choose HNSW, accepting its memory and build-time cost.

Exam tip: HNSW for recall and speed on data that keeps changing; IVF for quick, low-memory builds on a stable, fully loaded table.

Choosing an AWS Data Store: Redshift, DynamoDB, Aurora, S3, and MemoryDB — the lesson that teaches this.

What DEA-C01 domain 2 tests, topic by topic

The official exam guide breaks Data Store Management into 4 topics. The question bank follows the same split, so a weak topic shows up as a cluster of misses you can go back and read.

Published DEA-C01 practice questions per topic in Data Store Management
TopicWhat it coversQuestions
Choose a data storeOfficial DEA-C01 task statement (guide v1.1). Selecting and configuring storage for cost, performance, and access patterns (Amazon Redshift, EMR, AWS Lake Formation, Amazon RDS, DynamoDB, Kinesis Data Streams, Amazon MSK); applying storage to use cases (HNSW indexing with Aurora PostgreSQL, Amazon MemoryDB for fast key/value); migration tools (AWS Transfer Family); remote access (Redshift federated queries, materialized views, Redshift Spectrum); managing locks; open table formats (Apache Iceberg); vector index types (HNSW, IVF).44
Understand data cataloging systemsOfficial DEA-C01 task statement. Using data catalogs to consume data at source; building and referencing a technical data catalog (AWS Glue Data Catalog, Apache Hive metastore); discovering schemas and using Glue crawlers; synchronizing partitions with a catalog; creating source/target connections; creating and managing business data catalogs (Amazon SageMaker Catalog).44
Manage the lifecycle of dataOfficial DEA-C01 task statement. Load and unload operations between Amazon S3 and Amazon Redshift; managing S3 Lifecycle policies to change storage tier and to expire data by age; S3 versioning and DynamoDB TTL; deleting data to meet business and legal requirements; protecting data with appropriate resiliency and availability.44
Design data models and schema evolutionOfficial DEA-C01 task statement (guide v1.1). Designing schemas for Amazon Redshift, DynamoDB, and Lake Formation; addressing changes to data characteristics; schema conversion (AWS DMS Schema Conversion); establishing data lineage (Amazon SageMaker ML Lineage Tracking, SageMaker Catalog); indexing, partitioning, compression, and optimization; vectorization concepts (Amazon Bedrock knowledge base).44
Total176

Revise Data Store Management before you drill it

Other DEA-C01 domains

Data Store Management: your questions

Data Store Management is domain 2 of the DEA-C01 exam guide and carries 26% of the scored content — the 2nd-heaviest of the 4 domains. On a 65-question paper that works out to roughly 17 questions, though AWS does not publish an exact per-domain count and individual exam forms vary.

Source

The domain weight and topic list on this page come from the official DEA-C01 exam guide.