Task 1.1: Collect and store data.

• AA feature group with only the offline store, queried with Amazon Athena at inference time

  Incorrect

  The offline store is meant for cases where sub-second reads are not needed, such as exploration, training and batch inference. It is not a millisecond lookup path for a live endpoint.

• BA feature group with only the online store, exported nightly for training

  Incorrect

  The online store keeps only the record with the latest event time for each record identifier, so the earlier values that training needs are not there to export.

• CTwo feature groups that use the same record identifier, one per store

  Incorrect

  One feature group can enable both stores, and Feature Store keeps them in sync. Two separate groups would have to be written and kept consistent by the team, which adds work and risks training-serving skew.

• DA feature group with both the online store and the offline store enabled

  Correct

  The online store serves the latest record for each identifier with low latency through GetRecord, and the offline store in Amazon S3 keeps every historical record for training. When both are enabled they stay in sync.

Online store for the newest value at low latency, offline store for full history: enabling both on one feature group is the standard way to serve and train from the same feature definitions.

• ATurn on Firehose record format conversion to Apache Parquet

  Correct

  Firehose can convert JSON input to Apache Parquet or Apache ORC before writing to S3, using a deserializer, a schema from the Glue Data Catalog and a serializer. Columnar files let queries read only the columns they need.

• BAdd a Lambda transformation to the stream that rewrites each JSON record as a CSV line

  Incorrect

  CSV is still a row-oriented format, so a query that needs three columns still reads every row in full. It also adds a function to write and maintain.

• CTurn on dynamic partitioning and keep writing JSON objects

  Incorrect

  Dynamic partitioning groups objects under prefixes by keys in the data, which helps queries that filter on those keys. Each object is still JSON, so a query reads every field of every row it touches.

• DDeliver the stream to an S3 Express One Zone directory bucket instead

  Incorrect

  S3 Express One Zone is the lowest-latency storage class, but the objects would still be JSON and Athena would still scan whole records.

Parquet and ORC are columnar formats that take less space and let engines read only the referenced columns. Firehose converts JSON to either one natively when given a schema from the Glue Data Catalog.

• AIncrease the data retention period of the stream from 24 hours to 7 days

  Incorrect

  Retention controls how long records stay readable after they are written. It does not change how much data a shard accepts per second.

• BUse a high-cardinality partition key, such as the device ID, so records spread across shards

  Correct

  Kinesis maps each partition key to one shard. With a single key value every record lands on one shard, which accepts at most 1 MB per second of writes. Many distinct keys spread the puts across all shards.

• CRegister the feature pipeline as an enhanced fan-out consumer

  Incorrect

  Enhanced fan-out gives a consumer dedicated read throughput of up to 2 MB per second per shard. It helps readers, not producers that are throttled on writes.

• DRaise the stream capacity to at least 6 shards, or switch the stream to on-demand mode

  Correct

  Each shard accepts up to 1 MB per second or 1,000 records per second of writes, so 4 shards cannot take 6 MB per second even with an even spread. More shards, or on-demand mode that manages shards automatically, adds the capacity.

• ESwitch the producers from PutRecords batches to individual PutRecord calls

  Incorrect

  Batching with PutRecords, or the Kinesis Producer Library, is the recommended way to raise producer throughput. Single-record calls add overhead and do not lift the per-shard limit.

Two limits are hit at once: one hot shard caused by a constant partition key, and a stream that is too small for the total rate. Spreading keys fixes the first, and adding shards (or on-demand mode) fixes the second.

• AAn Amazon OpenSearch Service domain sized to keep the HNSW graphs in memory

  Incorrect

  Memory-based k-NN search loads the vector graphs into the RAM of the data nodes, so the domain must be sized and paid for around that memory all the time. It fits high-query-rate, low-latency search better than a rarely queried archive.

• BAn Amazon Aurora PostgreSQL-Compatible cluster with the pgvector extension

  Incorrect

  pgvector adds vector search to PostgreSQL, but the team would run and size a database cluster for the whole index, which does not match the goals of no infrastructure to manage and lowest cost.

• CAmazon S3 Vectors, with the embeddings in a vector index inside a vector bucket

  Correct

  S3 Vectors is purpose-built, cost-optimized vector storage with its own query API and no infrastructure to provision. It delivers subsecond latency for infrequent queries, and an index can hold billions of vectors of up to 4,096 dimensions.

• DEmbedding files in S3 Glacier Flexible Retrieval, restored when a query arrives

  Incorrect

  Objects in S3 Glacier Flexible Retrieval are archived and not available for real-time access; a copy must be restored before it can be read, so queries could not be answered in under a second.

S3 Vectors trades the very low latency of an in-memory engine for much lower storage and query cost at large scale. AWS positions OpenSearch for high query rates and low latency, and S3 Vectors for cost-effective storage and infrequent queries.

• AKeep file mode and attach an even larger volume to each instance

  Incorrect

  In file mode SageMaker AI downloads the whole dataset before training starts, so a larger volume makes room for the data but does not remove the wait.

• BSet the S3 data distribution type to ShardedByS3Key

  Incorrect

  ShardedByS3Key splits the dataset across the instances of a distributed job. Each instance still downloads its share before starting, and it does not help a single-instance job.

• CPoint the channel at an augmented manifest file in file mode

  Incorrect

  A manifest only lists which objects to use. In file mode the listed data is still downloaded in full before training begins.

• DSwitch the input channel to fast file mode

  Correct

  Fast file mode exposes the S3 objects through a file system interface and streams them on demand, so training starts without waiting for a full download and the dataset no longer has to fit on the instance.

File mode downloads first and trains second; fast file mode starts immediately and streams objects as the script reads them. For S3 prefixes that are read mostly sequentially, fast file mode is the simple fix.

• AAmazon Comprehend, with PII detection on the audio files

  Incorrect

  Comprehend is a natural language processing service that works on text. It cannot take audio files as input, so the calls must be transcribed first.

• BAmazon Textract, to extract the spoken words

  Incorrect

  Textract extracts text and data from scanned documents and images, not from audio recordings.

• CAmazon Transcribe, with PII redaction turned on

  Correct

  Transcribe converts speech in audio files to text, and its PII redaction option replaces personal information in the transcript, so the output is ready to use as training text.

• DAmazon Rekognition, to analyze the recordings

  Incorrect

  Rekognition analyzes images and videos. It does not turn speech into text.

Match the modality first: speech goes through Transcribe, documents through Textract, images and video through Rekognition, and text through Comprehend. Transcribe can redact PII as part of the transcription job.

• AAn Amazon Data Firehose stream per source

  Incorrect

  Firehose delivers streaming records to destinations; it does not join a database table with files already in S3.

• BAn AWS Glue ETL job with a JDBC connection

  Correct

  AWS Glue is a serverless data integration service that connects to many data sources, on premises and on AWS, through Glue connections, and runs ETL jobs that combine them into data lake tables.

• CAn S3 Lifecycle rule on the clickstream bucket

  Incorrect

  Lifecycle rules move or expire objects; they do not read databases or join data.

• DAn Amazon Kinesis Video Streams pipeline

  Incorrect

  Kinesis Video Streams ingests video from devices; it has nothing to do with joining tables.

Merging data from several sources into one training set is classic ETL; Glue connections reach databases on premises or in AWS, and Glue jobs do the joins.

• AMark both of the fields as non-filterable

  Incorrect

  Non-filterable metadata cannot be used in query filters, so queries could not be restricted to one tenant.

• BKeep both of the fields filterable (default)

  Incorrect

  Filterable metadata has stricter size limits, and long snippets that are never filtered on fit better as non-filterable metadata.

• Ctenant_id filterable, snippet non-filterable

  Correct

  Metadata is filterable by default unless declared non-filterable at index creation. Filterable metadata can be used in query filters but has stricter size limits, while non-filterable metadata cannot be filtered on but can hold larger data.

• DCreate the index first and mark fields later

  Incorrect

  Non-filterable metadata keys cannot be changed after the index is created; changing them requires a new index.

Plan vector metadata up front: fields used in filters stay filterable, bulky fields used only for display are non-filterable.

• AS3 Express One Zone for all of the raw files

  Incorrect

  Express One Zone is the lowest-latency class for frequently accessed data, which is the opposite of rarely read archives.

• BKeep everything in S3 Standard for seven years

  Incorrect

  Standard storage is priced for frequent access, so paying it for seven years of rarely read data wastes money.

• CDelete the raw files once training completes

  Incorrect

  Deleting them breaks the seven-year retention requirement.

• DA Lifecycle rule that archives files after 90 days

  Correct

  S3 Lifecycle transition actions move objects to lower-cost storage classes on a schedule, such as archiving them after a set number of days, and expiration actions can delete them after the retention period.

Storage decisions combine access pattern, retrieval time and compliance; lifecycle rules automate moving cold data to archive classes.

• AAmazon Bedrock Data Automation

  Correct

  Bedrock Data Automation processes documents, images, video and audio, returning standard outputs such as audio transcriptions and document summaries, or custom outputs that you define.

• BAmazon Kinesis Data Streams

  Incorrect

  Kinesis Data Streams carries records; it does not extract summaries or transcriptions from files.

• CAWS DataSync transfer tasks

  Incorrect

  DataSync moves files between storage systems; it does not analyze their content.

• DAWS Glue crawlers and classifiers

  Incorrect

  Crawlers catalog schemas of structured data; they do not transcribe audio or summarize documents.

For mixed unstructured inputs, a multimodal extraction service turns each data type into structured, storable output in one place.

• ADynamic partitioning on customer_id and date

  Correct

  Dynamic partitioning uses keys within the data, such as customer_id, to deliver records grouped into matching S3 prefixes, which minimizes the data scanned by queries.

• BA larger buffer interval only

  Incorrect

  Buffering changes how often files are written, not how they are organized for per-customer reads.

• CDelivery to S3 Glacier Flexible Retrieval

  Incorrect

  Archived objects are not available for real-time access, which training jobs and queries need.

• DRecord format conversion to Apache Parquet

  Correct

  Converting JSON to columnar Parquet lets queries and jobs read only the columns they need, which also reduces scanning.

• EA second Firehose stream with the same settings

  Incorrect

  Duplicating the stream doubles the data without changing its layout.

Design the landing layout for the reads: partition by the common filters and store columns, not rows.