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

Data Operations and Support practice questions

Data Operations and Support is worth 22% of the DEA-C01 exam — the 3rd-heaviest of the 4 domains. Automating data processing, analyzing data, maintaining and monitoring pipelines, and ensuring data quality. Official weighting 22%. 6 fully worked examples are further down this page, answers included.

Exam weight
22%
the 3rd-heaviest of the 4 domains
Questions
148
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 Operations and Support questions, fully explained

Questions from the DEA-C01 bank mapped to domain 3, 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 Operations and Support

An AWS Step Functions Standard workflow that loads a data warehouse failed overnight. Nobody configured CloudWatch Logs logging on the state machine. The on-call engineer must find which state failed, the input that state received, and the error and cause it returned. Where can the engineer find all three?

Choose one.

  • a
    The CloudTrail event history entries for the state machine's API calls

    CloudTrail records control-plane calls such as StartExecution or UpdateStateMachine. It does not record the state-by-state inputs and errors inside an execution.

  • b
    The execution's event history, in the console or from GetExecutionHistory Correct

    Correct. Standard workflows keep an event history for every execution, with each state's input and output and the error name and cause of the failing state, whether or not CloudWatch Logs logging is configured.

  • c
    The ExecutionsFailed metric for the state machine in Amazon CloudWatch

    The metric counts failed executions. It shows that something failed, not which state failed or with what input and error.

  • d
    The CloudWatch Logs log group that Step Functions creates for each execution

    Step Functions does not create a log group by default; execution logging to CloudWatch Logs is optional and must be configured. The stem says nobody configured it.

The concept

Step Functions Standard workflows record an event history for every execution: each state entered and exited with its input and output, and the error and cause of any failure.

Why that’s the answer

The execution event history is built into Standard workflows. The console graph highlights the failed state, and its events show the input, the error name and the cause; GetExecutionHistory returns the same data to scripts. CloudWatch Logs logging is an optional extra (and the main source for Express workflows), so it is absent here. CloudTrail covers API calls on the state machine rather than its internal steps, and CloudWatch metrics are counts.

How to reason it out
  1. Open the state machine and select the failed execution.
  2. Use the graph view to find the state marked as failed.
  3. Read that state's events for its input, error name and cause.
  4. Use GetExecutionHistory when the same detail is needed by automation.

Exam tip: For a failed Standard workflow, the execution event history answers which state failed, with what input and what error.

Automate Data Processing on AWS: Step Functions, MWAA, Lambda & EventBridge — the lesson that teaches this.

Question 2Data Operations and Support

A Python AWS Lambda function must start an existing AWS Glue job named daily-sales-etl and pass the processing date so that the job script can read it with getResolvedOptions(sys.argv, ['run_date']). Which boto3 call does this?

Choose one.

  • a
    glue.create_job(Name='daily-sales-etl', DefaultArguments={'--run_date': '2026-07-29'})

    create_job defines a new job; it does not run anything, and the job already exists. DefaultArguments sets values for future runs rather than starting one.

  • b
    glue.start_workflow_run(Name='daily-sales-etl', RunProperties={'--run_date': '2026-07-29'})

    start_workflow_run starts a Glue workflow, and daily-sales-etl is a job. Workflow run properties are also read through the workflow APIs, not as job script arguments.

  • c
    glue.start_job_run(JobName='daily-sales-etl', Arguments={'--run_date': '2026-07-29'}) Correct

    Correct. StartJobRun starts the existing job and returns a JobRunId straight away; arguments whose keys start with -- are passed to the script, where getResolvedOptions resolves run_date.

  • d
    glue.start_job_run(JobName='daily-sales-etl', Arguments={'run_date': '2026-07-29'})

    This starts the right job, but Glue job argument keys must be prefixed with --. getResolvedOptions looks for --run_date, so the script fails to resolve the argument.

The concept

Glue jobs are started from code with StartJobRun, which is asynchronous and returns a JobRunId. Run-time parameters go in Arguments with keys prefixed by --, and the script reads them with getResolvedOptions.

Why that’s the answer

Only start_job_run runs an existing job. Its Arguments map is passed to the script as command-line style parameters, and Glue requires each key to begin with -- so that getResolvedOptions can find it. The near-twin without the -- prefix starts the job but the script cannot resolve run_date. create_job only defines a job, and start_workflow_run targets a different resource type with its own run-property mechanism.

How to reason it out
  1. Identify the action: run an existing Glue job, not define one or start a workflow.
  2. Pick the API that runs a job: StartJobRun (start_job_run in boto3).
  3. Check the argument format: keys need the -- prefix for getResolvedOptions.
  4. Remember the call is asynchronous: keep the JobRunId to check status or react to the completion event.

Exam tip: Start a Glue job with start_job_run and pass parameters as Arguments keys that begin with --.

Automate Data Processing on AWS: Step Functions, MWAA, Lambda & EventBridge — the lesson that teaches this.

Question 3Data Operations and Support

An AWS Lambda function transforms a daily batch file. As volume grew, the transformation now needs about 40 minutes and roughly 12 GB of memory, and the function times out. The code is Python built on DataFrame logic that already runs under PySpark. The team wants a managed serverless option started on the same daily schedule. What should the data engineer do?

Choose one.

  • a
    Raise the function's timeout to 60 minutes and its memory to 12 GB

    Lambda caps the timeout at 15 minutes and memory at 10,240 MB, so neither setting can be raised to what the job needs.

  • b
    Move the work into an AWS Glue Spark job run by a daily Glue trigger Correct

    Correct. Glue runs Spark serverlessly with no time limit at this scale and memory sized by worker type and count, and the PySpark-ready logic moves across with little change. A schedule trigger or EventBridge Scheduler starts it daily.

  • c
    Split the file so two parallel Lambda functions each process half of it

    Halving 40 minutes of work still leaves about 20 minutes per function, beyond the 15-minute limit, and splitting does not fix the memory requirement.

  • d
    Run the script as a daily step on a long-running Amazon EMR on EC2 cluster

    EMR runs the PySpark logic without Lambda's limits, but a long-running EMR on EC2 cluster is infrastructure the team must size, patch and pay for between runs, which breaks the managed serverless requirement.

The concept

Lambda is the automation glue for short, light work. Its 15-minute timeout and 10,240 MB memory ceiling mean heavy batch transformation belongs in AWS Glue or Amazon EMR, with Lambda or a scheduler only starting it.

Why that’s the answer

The workload has outgrown Lambda's hard limits on both time and memory, so options that keep the work inside Lambda fail: raising the settings is impossible, and splitting in two still leaves about 20 minutes per half. That leaves two Spark engines. A long-running EMR on EC2 cluster would run the code, but it is a cluster to manage and pay for all day, not a managed serverless option. A Glue Spark job is serverless, scales memory through worker type and count, has no 15-minute cap, and accepts the existing PySpark-compatible logic.

How to reason it out
  1. Compare the needs (about 40 minutes, about 12 GB) with Lambda's limits (15 minutes, 10,240 MB).
  2. Reject options that keep the work inside Lambda, however it is split or extended.
  3. Of the Spark engines, reject the one that leaves a cluster running between daily runs.
  4. Pick the serverless engine that runs the existing Spark-style code, AWS Glue, on a schedule trigger or EventBridge Scheduler.

Exam tip: When a Lambda transformation hits the 15-minute or memory ceiling, move the work to Glue or EMR and let Lambda or a schedule only start it.

Automate Data Processing on AWS: Step Functions, MWAA, Lambda & EventBridge — the lesson that teaches this.

Question 4Data Operations and Support

Business analysts with no programming experience must standardize date formats, remove duplicate rows, and fill missing values in CSV files that land in Amazon S3 every week. They want to define the cleanup steps visually once and have the same steps rerun automatically on each new week's files. Which approach meets these requirements?

Choose one.

  • a
    AWS Glue Studio job with a custom PySpark code node, run on a schedule

    A Glue job can run on a schedule, but a custom PySpark code node means writing code, which the analysts cannot do.

  • b
    Amazon EMR Serverless application running scheduled Spark SQL scripts

    EMR Serverless removes cluster management, but the cleanup still has to be written as Spark SQL scripts, which is not a visual, no-code workflow.

  • c
    AWS Lambda function using pandas, triggered by new S3 object events

    This automates the run on each new file, but the cleanup logic is Python code that the analysts would have to write and maintain.

  • d
    AWS Glue DataBrew project whose recipe runs as a scheduled recipe job Correct

    Correct. DataBrew lets analysts build a recipe visually from built-in transformations (date formats, deduplication, filling missing values), and a recipe job applies the saved recipe to new data on a schedule.

The concept

AWS Glue DataBrew is no-code data preparation: users build a recipe of built-in transformations on a sample in a project, then run the recipe as a recipe job, on a schedule if needed, against the full data.

Why that’s the answer

The deciding constraint is that the users cannot write code, yet the steps must be reusable and automated. DataBrew recipes are saved, versioned lists of visual transformations, and recipe jobs rerun them on new files on a schedule. Every other option automates the run but requires the cleanup to be written as code.

How to reason it out
  1. Note the users: analysts with no programming experience.
  2. Note the need: visual cleanup steps saved once and rerun on a schedule.
  3. Eliminate engines whose logic must be written in PySpark, SQL or Python.
  4. Choose DataBrew: a recipe built in a project, run by a scheduled recipe job.

Exam tip: No-code, repeatable data cleanup for analysts is a DataBrew recipe run by a scheduled recipe job.

Automate Data Processing on AWS: Step Functions, MWAA, Lambda & EventBridge — the lesson that teaches this.

Question 5Data Operations and Support

A data engineer occasionally needs to run ad hoc SQL against Parquet files in Amazon S3 that are already cataloged in the AWS Glue Data Catalog. Queries happen a few times a month, nothing may be provisioned or loaded, and cost must follow the amount of data each query reads. Which service should the engineer use?

Choose one.

  • a
    Amazon Redshift Serverless with an external schema over the Data Catalog

    Redshift Serverless can query the cataloged files through an external schema without provisioning, but it bills for compute capacity (RPU-hours) while queries run, not for the data each query reads.

  • b
    Amazon EMR Serverless running Spark SQL jobs over the Data Catalog tables

    EMR Serverless avoids clusters but bills for the vCPU, memory and storage the job uses, and each query has to be packaged as a job rather than run as ad hoc SQL.

  • c
    Amazon RDS for PostgreSQL with the Parquet files imported into tables

    This requires provisioning a database instance and loading the data, both of which the stem rules out.

  • d
    Amazon Athena running SQL queries over the existing Data Catalog tables Correct

    Correct. Athena is serverless, queries the files in place through the Data Catalog, and charges by the amount of data each query scans.

The concept

Amazon Athena is serverless SQL over data in S3, using Data Catalog table definitions and priced per amount of data scanned.

Why that’s the answer

Several services can run SQL over cataloged S3 data without servers, so the pricing constraint decides. Athena bills by data scanned, which suits a few queries a month, and needs no loading. Redshift Serverless and EMR Serverless both avoid provisioning but bill for compute capacity used, and RDS needs an instance plus a data load.

How to reason it out
  1. Note the constraints: data stays in S3, nothing provisioned or loaded, pay by data read.
  2. Discard options that need an instance or a load (RDS).
  3. Compare the serverless options by billing model: compute capacity versus data scanned.
  4. Choose Athena.

Exam tip: Occasional SQL on cataloged S3 data, billed by what each query scans, is Athena.

Automate Data Processing on AWS: Step Functions, MWAA, Lambda & EventBridge — the lesson that teaches this.

Question 6Data Operations and Support

During month-end runs, tasks in an Amazon MWAA environment wait in the queued state for a long time and DAG completion times climb. CloudWatch shows the worker count flat at 10 for hours with high worker CPU, and 10 is the MaxWorkers value the environment was created with. The DAG code has not changed. What should the data engineer do?

Choose one.

  • a
    Raise the environment's maximum worker count Correct

    Correct. MWAA autoscales workers between the minimum and maximum you set. With workers pinned at the maximum and busy, raising the maximum (or moving to a larger environment class with more capacity per worker) lets queued tasks start.

  • b
    Raise the number of schedulers in the environment

    Schedulers decide which tasks are ready and queue them; the tasks are already queued. More schedulers would queue work faster for workers that have no free capacity.

  • c
    Raise the environment's minimum worker count

    The minimum is the floor autoscaling keeps when the environment is quiet. Workers are already at the ceiling, so raising the floor adds nothing during the peak.

  • d
    Raise the task retries and retry delay in default_args

    Retries apply after a task fails. These tasks have not failed; they are waiting for a worker, so retry settings change nothing.

The concept

MWAA runs tasks on workers that autoscale between a configured minimum and maximum. Tasks that sit queued while workers are at the maximum and busy point to worker capacity.

Why that’s the answer

The metrics locate the bottleneck: the worker count is pinned at the configured MaxWorkers with high CPU. Queued tasks are tasks the scheduler has already released that no worker can pick up. Raising the maximum worker count lets autoscaling add capacity for the peak, and a larger environment class raises the capacity of each worker if tasks are heavy. Raising the minimum changes only the quiet-time floor, adding schedulers speeds up queuing for workers that have no room, and retries only matter after failures.

How to reason it out
  1. Read the symptom: tasks queued, not failing.
  2. Find the saturated component: the worker count sits at the MaxWorkers value with high CPU.
  3. Separate the maximum (peak ceiling) from the minimum (idle floor), and rule out schedulers and retries.
  4. Raise the maximum worker count, or the environment class if each task is heavy.

Exam tip: Queued MWAA tasks with workers pinned at MaxWorkers mean a higher maximum, not a higher minimum, more schedulers or more retries.

Automate Data Processing on AWS: Step Functions, MWAA, Lambda & EventBridge — the lesson that teaches this.

What DEA-C01 domain 3 tests, topic by topic

The official exam guide breaks Data Operations and Support 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 Operations and Support
TopicWhat it coversQuestions
Automate data processing by using AWS servicesOfficial DEA-C01 task statement. Orchestrating pipelines (Amazon MWAA, AWS Step Functions); troubleshooting managed workflows; calling SDKs; using service features to process data (Amazon EMR, Redshift, AWS Glue); consuming and maintaining data APIs; preparing data for transformation (AWS Glue DataBrew, Amazon SageMaker Unified Studio); querying data (Amazon Athena); using AWS Lambda to automate processing; managing events and schedulers (Amazon EventBridge).37
Analyze data by using AWS servicesOfficial DEA-C01 task statement. Visualizing data (AWS Glue DataBrew, Amazon QuickSight); verifying and cleaning data (Lambda, Athena, QuickSight, Jupyter notebooks, Amazon SageMaker Data Wrangler); using SQL in Amazon Redshift and Athena to query and create views; using Athena notebooks with Apache Spark; tradeoffs between provisioned and serverless services; data aggregation, rolling averages, grouping, and pivoting.37
Maintain and monitor data pipelinesOfficial DEA-C01 task statement. Extracting logs for audits; deploying logging and monitoring for traceability; using notifications to send alerts; troubleshooting performance; tracking API calls with AWS CloudTrail; troubleshooting and maintaining pipelines (AWS Glue, Amazon EMR); using Amazon CloudWatch Logs; analyzing logs (Athena, EMR, Amazon OpenSearch Service, CloudWatch Logs Insights).37
Ensure data qualityOfficial DEA-C01 task statement. Running data quality checks while processing (for example, checking for empty fields); defining data quality rules (AWS Glue DataBrew); investigating data consistency; data sampling techniques; implementing data skew mechanisms.37
Total148

Revise Data Operations and Support before you drill it

Other DEA-C01 domains

Data Operations and Support: your questions

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