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

Data Ingestion and Transformation practice questions

Data Ingestion and Transformation is worth 34% of the DEA-C01 exam — the heaviest of the 4 domains. Ingesting streaming and batch data, transforming and processing it, orchestrating ETL pipelines, and applying programming concepts. Official weighting 34%. 6 fully worked examples are further down this page, answers included.

Exam weight
34%
the heaviest of the 4 domains
Questions
232
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 Ingestion and Transformation questions, fully explained

Questions from the DEA-C01 bank mapped to domain 1, 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 Ingestion and Transformation

An on-premises Oracle database supports a live ordering system. A data engineer must copy the existing order rows into an Amazon S3 data lake and then keep S3 current with every insert, update and delete, while placing minimal load on the source. Which approach should the engineer use?

Choose one.

  • a
    A nightly AWS Glue JDBC job with bookmarks on the order ID

    A bookmark on a monotonically increasing key picks up new rows, but it never sees updates or deletes to existing rows, and nightly runs are not continuous.

  • b
    An AWS DMS task of type full load, rerun each night

    A nightly full load re-reads every table each time, which loads the source heavily and leaves S3 up to a day behind.

  • c
    An AWS DMS task of type CDC, started from the current time

    A CDC task without a full load captures changes from its start point but never copies the rows that already exist, so the lake would be missing historical orders.

  • d
    An AWS DMS task of type full load and ongoing replication Correct

    Full load plus CDC copies the existing rows once and then reads the database transaction log to apply inserts, updates and deletes continuously, with little load on the source.

The concept

AWS DMS tasks come in three types: full load (one-time copy), CDC only (changes from a start point) and full load plus CDC (copy, then continuous changes read from the transaction log).

Why that’s the answer

The requirement has two halves: the existing rows and every later change, including deletes. Full load and ongoing replication covers both and reads changes from the redo log rather than by querying tables. Full load alone misses continuity and hammers the source, CDC only misses history, and a Glue JDBC bookmark sees only newly inserted keys.

How to reason it out
  1. Split the requirement: historical rows plus continuous inserts, updates and deletes.
  2. Note that deletes and updates require log-based change capture, not key-based incremental reads.
  3. Match both halves to one DMS task type: full load plus CDC.

Exam tip: Existing data plus every later change from a relational source means an AWS DMS full-load-and-CDC task.

Data Ingestion on AWS: Kinesis, MSK, DMS, Glue, and Batch Patterns — the lesson that teaches this.

Question 2Data Ingestion and Transformation

An application stores customer profiles in an Amazon DynamoDB table. A data engineer must run processing logic within seconds of any profile being created or modified, using the old and new versions of the item, without changing the application code. Which solution meets these requirements?

Choose one.

  • a
    Turn on DynamoDB Streams and read the stream with an AWS Glue streaming job

    AWS Glue streaming jobs read from Kinesis Data Streams and Apache Kafka sources, not directly from a DynamoDB stream.

  • b
    Run an AWS Glue job at five-minute intervals that scans the table

    A scheduled scan consumes read capacity, cannot see the previous version of an item, and runs minutes rather than seconds after the change.

  • c
    Schedule incremental exports of the table to S3 and process each export

    Incremental export to S3 works on export windows of at least 15 minutes, so changes are processed far later than within seconds.

  • d
    Turn on DynamoDB Streams and add a Lambda event source mapping Correct

    DynamoDB Streams records every item-level change, with the NEW_AND_OLD_IMAGES view type supplying both versions, and a Lambda event source mapping invokes the function within seconds without any change to the writer.

The concept

DynamoDB Streams emits an ordered, item-level change record for every write; with the NEW_AND_OLD_IMAGES view type each record carries the item before and after the change.

Why that’s the answer

The table itself must be the trigger, because the application cannot change. DynamoDB Streams with a Lambda event source mapping reacts within seconds and provides old and new images. A Glue streaming job cannot use a DynamoDB stream as its source, and scheduled scans or incremental exports run minutes behind.

How to reason it out
  1. Note the constraints: seconds of latency, old and new item versions, no application changes.
  2. Change data must come from the table itself: DynamoDB Streams with NEW_AND_OLD_IMAGES.
  3. Choose a consumer that reads DynamoDB Streams natively: a Lambda event source mapping.

Exam tip: React to DynamoDB item changes without touching the writer: DynamoDB Streams plus a Lambda event source mapping.

Data Ingestion on AWS: Kinesis, MSK, DMS, Glue, and Batch Patterns — the lesson that teaches this.

Question 3Data Ingestion and Transformation

A data engineer loads a single 500 GB gzip-compressed CSV file from Amazon S3 into a multi-node Amazon Redshift cluster each night. The load takes hours, and CloudWatch shows most compute slices idle during it. What should the engineer do to shorten the load?

Choose one.

  • a
    Keep the single file and raise the WLM query concurrency for the load

    Concurrency lets more queries run at once; it does not let one COPY read a single gzip file with more than one slice.

  • b
    Split the file into parts and run one COPY per part, one after another

    Splitting is right, but sequential COPY commands each load in turn, so slices still sit idle and every commit adds overhead.

  • c
    Keep the single gzip file and name it in a manifest for one COPY command

    A manifest only lists which files to load; one gzip file cannot be split into ranges, so a single slice still reads all of it.

  • d
    Split the file into equal parts and load them with one COPY command Correct

    One COPY over multiple similarly sized compressed files (ideally a multiple of the slice count) lets every slice load files in parallel.

The concept

Redshift COPY loads in parallel by spreading input across slices; a compressed file cannot be split into scan ranges, so one compressed file is read by one slice.

Why that’s the answer

The symptom (idle slices) points at a single compressed input file. COPY can split a large uncompressed delimited file into scan ranges automatically, but a gzip file has to be read start to finish by one slice. Splitting it into similarly sized compressed files, ideally a multiple of the slice count, and loading them with one COPY spreads the work over every slice in one transaction. A manifest only names the files to load, sequential COPYs load one part at a time, and more WLM concurrency does not split a single read.

How to reason it out
  1. Read the symptom: most slices idle during the load.
  2. Recall that a compressed input file cannot be split into scan ranges, so one slice reads it.
  3. Rule out changes that keep one compressed file (manifest, WLM concurrency) or serialise the parts.
  4. Split into equal-sized compressed files and load them with a single COPY.

Exam tip: Compressed input to Redshift: one COPY over many similarly sized files, not one big file or many sequential COPYs.

Data Ingestion on AWS: Kinesis, MSK, DMS, Glue, and Batch Patterns — the lesson that teaches this.

Question 4Data Ingestion and Transformation

A marketing team needs campaign data from Salesforce copied into Amazon S3 every night, unattended. The data engineering team wants a fully managed solution with no custom code to write or maintain and no infrastructure to run. Which solution should they use?

Choose one.

  • a
    An AWS Lambda function on an EventBridge schedule that calls Salesforce

    This runs unattended, but the team must write and maintain the Salesforce API client, pagination and token handling in the function.

  • b
    An AWS DMS task that uses Salesforce as its source endpoint

    AWS DMS migrates databases; Salesforce is not a supported DMS source endpoint.

  • c
    An Amazon AppFlow flow with a scheduled trigger Correct

    AppFlow has a managed Salesforce connector and a schedule-triggered flow runs nightly to S3 with no code or infrastructure.

  • d
    An Amazon AppFlow flow with an on-demand trigger

    An on-demand flow runs only when someone or something starts it, so it does not run nightly unattended by itself.

The concept

Amazon AppFlow moves data between SaaS applications and AWS with managed connectors; a flow runs on demand, on a schedule, or on a SaaS event.

Why that’s the answer

AppFlow is the managed, no-code path from Salesforce to S3, and the scheduled trigger is what makes it run nightly without anyone starting it. The Lambda option is code the team must maintain, and DMS has no Salesforce source.

How to reason it out
  1. Recognise a SaaS source with a no-code, no-infrastructure requirement: Amazon AppFlow.
  2. Choose the flow trigger that matches nightly unattended runs: scheduled, not on demand.

Exam tip: SaaS to S3 with no code: Amazon AppFlow; choose the trigger type (on demand, scheduled, event) that matches how often it must run.

Data Ingestion on AWS: Kinesis, MSK, DMS, Glue, and Batch Patterns — the lesson that teaches this.

Question 5Data Ingestion and Transformation

A data engineer must start an existing AWS Glue ETL job every day at 02:00 London local time, and the run must stay at 02:00 local time across daylight-saving changes. The job has no dependencies. Which scheduling approach meets this requirement with the LEAST operational overhead?

Choose one.

  • a
    A Glue scheduled trigger with the expression cron(0 2 * * ? *)

    Glue time-based triggers evaluate cron expressions in UTC, so the job would run at 03:00 London time for half the year.

  • b
    An EventBridge Scheduler schedule using cron(0 2 * * ? *) in Europe/London Correct

    EventBridge Scheduler lets a cron schedule carry a time zone and adjusts for daylight saving, and its universal target can call the Glue StartJobRun API directly.

  • c
    An EventBridge scheduled rule with cron(0 2 * * ? *) on the default bus

    Scheduled rules on an event bus evaluate cron expressions in UTC only, so the run shifts by an hour when the clocks change.

  • d
    An Amazon MWAA provisioned environment with a DAG on a London-time schedule

    A time-zone-aware DAG works, but it means authoring and deploying an Airflow workflow and running a provisioned environment continuously for one independent job.

The concept

EventBridge Scheduler supports time zones (and daylight saving) on cron schedules; Glue triggers and EventBridge scheduled rules evaluate cron in UTC.

Why that’s the answer

Two facts combine. The time must follow local daylight saving, which rules out the UTC-only schedulers: Glue scheduled triggers and EventBridge scheduled rules. Of the time-zone-aware options, EventBridge Scheduler is serverless and calls StartJobRun directly, while a provisioned MWAA environment would work but adds an Airflow workflow and a continuously running environment for a single job.

How to reason it out
  1. Notice the local-time-with-daylight-saving requirement.
  2. Eliminate schedulers that evaluate cron only in UTC: Glue triggers and scheduled rules.
  3. Of the remaining time-zone-aware options, choose the one with least overhead.
  4. Pick EventBridge Scheduler with the Europe/London time zone.

Exam tip: Need a local-time schedule that follows daylight saving? Use EventBridge Scheduler with a time zone; Glue triggers and scheduled rules run in UTC.

Data Ingestion on AWS: Kinesis, MSK, DMS, Glue, and Batch Patterns — the lesson that teaches this.

Question 6Data Ingestion and Transformation

A data platform team is moving hundreds of existing Apache Airflow DAGs, with branching, retries and cross-DAG dependencies, from an on-premises cluster to AWS. They must run the DAGs with minimal changes to the Python code and must not manage scheduler or worker servers. Which service should they choose?

Choose one.

  • a
    AWS Glue workflows rebuilt from the logic of each DAG

    Glue workflows chain Glue jobs and crawlers with triggers; every DAG would have to be rebuilt, and many Airflow operators have no Glue equivalent.

  • b
    AWS Step Functions state machines translated from each DAG

    Step Functions is a managed orchestrator, but translating hundreds of DAGs into state machines is a rewrite, not a lift-and-shift.

  • c
    Amazon Managed Workflows for Apache Airflow environments Correct

    Amazon MWAA runs standard Airflow, so existing DAG files deploy with minimal changes while AWS manages the scheduler, workers and metadata database.

  • d
    Apache Airflow on an Amazon EC2 Auto Scaling group

    This runs the DAGs unchanged, but the team would install, patch and scale the Airflow servers themselves.

The concept

Amazon MWAA is managed Apache Airflow: existing DAGs run as-is, without operating Airflow infrastructure.

Why that’s the answer

Two constraints decide it: keep the DAG code and avoid managing servers. MWAA satisfies both. Glue workflows and Step Functions mean rewriting every DAG, and self-managed Airflow on EC2 keeps the code but breaks the no-servers constraint.

How to reason it out
  1. Note the existing Airflow DAGs that must keep running with minimal changes.
  2. Note that the team will not operate scheduler or worker servers.
  3. Choose managed Airflow: Amazon MWAA.

Exam tip: Existing Airflow DAGs and no servers to run means Amazon MWAA.

Data Ingestion on AWS: Kinesis, MSK, DMS, Glue, and Batch Patterns — the lesson that teaches this.

What DEA-C01 domain 1 tests, topic by topic

The official exam guide breaks Data Ingestion and Transformation 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 Ingestion and Transformation
TopicWhat it coversQuestions
Perform data ingestionOfficial DEA-C01 task statement (guide v1.1). Reading streaming sources (Amazon Kinesis, Amazon MSK, DynamoDB Streams, AWS DMS, AWS Glue, Amazon Redshift) and batch sources (Amazon S3, Glue, Amazon EMR, DMS, Redshift, AWS Lambda, Amazon AppFlow); batch-ingestion configuration; consuming data APIs; setting up schedulers (Amazon EventBridge, Apache Airflow, time-based) for jobs and crawlers; event triggers (S3 Event Notifications, EventBridge); calling a Lambda function from Kinesis; IP allowlists; throttling and rate limits (DynamoDB, Amazon RDS, Kinesis); managing fan-in/fan-out for streaming distribution; replayability of ingestion pipelines; stateful vs stateless transactions.58
Transform and process dataOfficial DEA-C01 task statement. Optimizing container usage (Amazon EKS, ECS); connecting via JDBC/ODBC; integrating data from multiple sources; optimizing cost while processing; implementing transformation services by requirement (Amazon EMR, AWS Glue, Lambda, Amazon Redshift); converting formats (CSV to Apache Parquet); troubleshooting transformation failures and performance; creating data APIs; defining volume, velocity, and variety; integrating large language models (LLMs) for data processing.58
Orchestrate data pipelinesOfficial DEA-C01 task statement. Using orchestration services to build ETL workflows (Lambda, EventBridge, Amazon Managed Workflows for Apache Airflow [MWAA], AWS Step Functions, AWS Glue workflows); building pipelines for performance, availability, scalability, resiliency, and fault tolerance; implementing and maintaining serverless workflows; using notification services for alerts (Amazon SNS, Amazon SQS).58
Apply programming conceptsOfficial DEA-C01 task statement. Optimizing code to reduce runtime; configuring Lambda concurrency and performance; using languages and frameworks (Python, SQL, Scala, R, Java, Bash, PowerShell); software-engineering best practices (version control, testing, logging, monitoring); packaging and deploying serverless data pipelines with AWS SAM; using and mounting storage volumes from within Lambda functions; Infrastructure as Code (AWS CloudFormation, AWS CDK); CI/CD for data pipelines; distributed computing; data structures and algorithms.58
Total232

Revise Data Ingestion and Transformation before you drill it

Other DEA-C01 domains

Data Ingestion and Transformation: your questions

Data Ingestion and Transformation is domain 1 of the DEA-C01 exam guide and carries 34% of the scored content — the heaviest of the 4 domains. On a 65-question paper that works out to roughly 22 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.