DEA-C01 — AWS Certified Data Engineer – Associate Quick Reference

Exam identity and quick-use approach

This Quick Reference supports independent preparation for the AWS Certified Data Engineer – Associate (DEA-C01) exam from AWS. Use it as a compact decision guide for scenario questions: identify the data source, ingestion pattern, transformation need, storage/query target, governance model, and operational concern.

High-yield DEA-C01 thinking pattern:

1. Ingest: batch files, database CDC, SaaS, stream, events, or messages.
2. Store: Amazon S3 data lake, Amazon Redshift warehouse, operational database, or search/time-series target.
3. Catalog and govern: AWS Glue Data Catalog, AWS Lake Formation, IAM, AWS KMS.
4. Transform: AWS Glue, Amazon EMR, AWS Lambda, Amazon Managed Service for Apache Flink, SQL CTAS, or Redshift SQL.
5. Operate: monitor, retry, validate, secure, optimize, and troubleshoot.

Core AWS data engineering architecture

    flowchart LR
	    A[Sources: databases, SaaS, files, apps, streams] --> B[Ingestion: DMS, DataSync, AppFlow, Kinesis, Firehose, MSK]
	    B --> C[S3 raw zone]
	    C --> D[Catalog: AWS Glue Data Catalog]
	    C --> E[Transform: AWS Glue, EMR, Lambda, Athena CTAS]
	    E --> F[S3 curated zone]
	    F --> G[Query: Athena, Redshift Spectrum, EMR, QuickSight]
	    E --> H[Warehouse: Amazon Redshift]
	    D --> I[Governance: Lake Formation, IAM, KMS]
	    G --> J[Consumers]
	    H --> J
	    B --> K[Ops: CloudWatch, CloudTrail, EventBridge]
	    E --> K
	    H --> K

Service selection matrix

Scenario keyword shortcuts

Data ingestion reference

Batch, file, and database ingestion

Streaming ingestion

Ingestion design rules

• Separate raw and curated data. Land immutable source data first, then transform.
• Make ingestion idempotent. Assume retries can create duplicate deliveries.
• Capture metadata: source, ingestion timestamp, schema version, batch ID, and lineage.
• Use partition-friendly timestamps. Common S3 partitions include date or hour, but avoid creating excessive tiny partitions.
• Validate early. Use data quality checks before promoting data into curated zones.
• Monitor lag and failures. Streams, DMS tasks, Firehose delivery, and Glue jobs all expose operational signals.

S3 data lake design

Data lake zones

File format selection

Partitioning and layout rules

Example S3 layout:

s3://company-data-lake/raw/source=salesforce/object=account/ingest_date=2026-06-18/
s3://company-data-lake/curated/domain=sales/table=orders/order_date=2026-06-18/
s3://company-data-lake/quarantine/source=orders/ingest_date=2026-06-18/

AWS Glue and Data Catalog reference

Glue components

Crawler vs explicit schema

Glue ETL exam points

Illustrative Glue PySpark pattern:

from awsglue.context import GlueContext
from pyspark.context import SparkContext

glue_ctx = GlueContext(SparkContext.getOrCreate())

orders = glue_ctx.create_dynamic_frame.from_catalog(
    database="raw",
    table_name="orders",
    push_down_predicate="ingest_date >= '2026-06-01'"
)

df = orders.toDF().dropDuplicates(["order_id"])

df.write.mode("append") \
    .partitionBy("order_date") \
    .parquet("s3://example-data-lake/curated/orders/")

Example AWS Glue Data Quality rule style:

Rules = [
  IsComplete "order_id",
  IsUnique "order_id",
  ColumnValues "amount" >= 0,
  ColumnExists "order_date"
]

Athena reference

Athena CTAS pattern:

CREATE TABLE curated_orders
WITH (
  format = 'PARQUET',
  partitioned_by = ARRAY['order_date'],
  external_location = 's3://example-data-lake/curated/orders/'
) AS
SELECT
  order_id,
  customer_id,
  amount,
  order_status,
  order_date
FROM raw_orders
WHERE order_date >= DATE '2026-01-01';

Partition repair pattern for Hive-style S3 paths:

MSCK REPAIR TABLE raw_orders;

Common Athena traps:

• Athena queries data in S3; it does not ingest or move data by itself.
• Catalog permissions alone are not enough if S3 or KMS denies access.
• Crawlers update metadata; they do not optimize file format or clean data.
• Partition projection can reduce partition metadata management, but the S3 path pattern must match the table definition.
• Columnar formats help most when queries select only needed columns.

Amazon Redshift reference

Redshift vs Athena vs S3 lake

Redshift design points

COPY from S3 pattern:

COPY analytics.orders
FROM 's3://example-data-lake/curated/orders/'
IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftLoadRole'
FORMAT AS PARQUET;

UNLOAD to S3 pattern:

UNLOAD ('SELECT order_date, SUM(amount) AS revenue FROM analytics.orders GROUP BY order_date')
TO 's3://example-data-lake/exports/revenue/'
IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftUnloadRole'
FORMAT AS PARQUET;

Redshift troubleshooting shortcuts:

Streaming and event processing reference

Kinesis, Firehose, MSK, Flink

Streaming design traps

• Partition keys determine ordering and load distribution. Bad keys create hot partitions.
• Assume at-least-once delivery in many pipelines; design deduplication and idempotent sinks.
• Firehose buffering means it is usually not the answer for the lowest-latency custom consumer requirement.
• Lambda works for lightweight stream processing, not complex stateful analytics.
• Use dead-letter, backup, or quarantine patterns for failed records.
• Monitor consumer lag, delivery failures, throttling, and error logs.

Transformation and orchestration choices

Orchestration exam distinctions

Security, governance, and access control

Data access control layers

Governance decision table

Least-privilege reminders

• Grant jobs only the S3 prefixes, catalog databases/tables, KMS keys, and logs they need.
• Separate roles for ingestion, transformation, catalog administration, and consumption.
• For cross-account sharing, check all layers: IAM, resource policy, Lake Formation, S3, and KMS.
• Avoid embedding credentials in scripts, notebooks, job parameters, or environment variables when Secrets Manager is appropriate.
• Use encryption in transit and at rest for data pipelines.

Operations, monitoring, and troubleshooting

Service signals

Troubleshooting table

Data quality, schema, and reliability

Reliability checklist:

• Can the pipeline be safely retried?
• Are failed records preserved?
• Is raw source data immutable?
• Are schema changes detected before breaking consumers?
• Are job failures visible through alarms or events?
• Are downstream writes atomic enough for the service and format used?
• Are permissions least-privilege but sufficient across IAM, S3, KMS, and Lake Formation?

Cost and performance optimization

High-yield optimization principle: for analytics on S3, reduce bytes scanned and reduce file/partition overhead before scaling compute.

Common DEA-C01 traps

Final review checklist

Before the exam, be able to answer these quickly:

• Which service ingests files, database CDC, SaaS, events, streams, and Kafka?
• When should data be stored in S3, Redshift, or queried by Athena?
• How do Glue Data Catalog, crawlers, Lake Formation, and Glue jobs differ?
• How do you optimize S3 analytics with Parquet, compression, partitioning, and compaction?
• What permission layers can block a query: IAM, S3, KMS, Lake Formation, catalog, or network?
• How do you troubleshoot failed Glue, Athena, Redshift COPY, DMS, Kinesis, and Firehose workflows?
• Which orchestration service fits: Step Functions, Glue workflows, MWAA, or EventBridge?
• How do you make pipelines idempotent, observable, recoverable, and governed?

Next step

Use this Quick Reference as a checklist, then practice scenario questions that force you to choose between similar AWS services, especially Glue vs EMR, Athena vs Redshift, Kinesis Data Streams vs Firehose, DMS vs DataSync, and IAM vs Lake Formation permission issues.