DEA-C01 — AWS Certified Data Engineer – Associate Exam Blueprint

How to Use This Exam Blueprint

Use this checklist as a practical readiness map for the AWS Certified Data Engineer – Associate (DEA-C01) exam from AWS. It is not a replacement for the official exam guide, and it does not claim exact exam weighting. Instead, it turns likely exam topic areas into concrete review tasks.

For each area, ask:

• Can I choose the right AWS service for the scenario?
• Can I explain why the wrong options are wrong?
• Can I identify security, cost, reliability, and operational tradeoffs?
• Can I troubleshoot a broken pipeline from symptoms, logs, permissions, schema changes, or data quality signals?
• Can I connect ingestion, storage, transformation, cataloging, orchestration, monitoring, and governance into an end-to-end data architecture?

DEA-C01 readiness areas at a glance

Core service selection checklist

Ingestion and movement

Storage and data layout

Transformation and processing

“Can you do this?” skills checklist

Architecture and service choice

• Given batch, streaming, and CDC requirements, choose an ingestion pattern and justify it.
• Distinguish Amazon Kinesis Data Streams, Amazon Data Firehose, Amazon MSK, AWS DMS, and file-based S3 ingestion.
• Choose between Amazon Athena, Amazon Redshift, AWS Glue, Amazon EMR, and Amazon OpenSearch Service for analytics or processing scenarios.
• Identify when a serverless approach is simpler than provisioning and operating clusters.
• Identify when custom code is justified versus managed connectors or managed ETL.
• Design a pipeline with landing, raw, curated, and consumption layers.
• Recognize which services require a Data Catalog, table metadata, or partition metadata.
• Choose orchestration for multi-step jobs, retries, branching, scheduled runs, and event-driven starts.

Data modeling, formats, and query performance

• Choose Parquet or ORC for analytical workloads when column pruning and compression matter.
• Explain why JSON or CSV may be acceptable for interchange but inefficient for repeated analytics.
• Design partition keys that match common query predicates.
• Detect an over-partitioned table from symptoms such as excessive metadata, many tiny files, or slow planning.
• Detect an under-partitioned table from symptoms such as high scan volume.
• Explain how compaction improves query performance.
• Explain when denormalization, star schemas, or curated aggregates may support analytics.
• Recognize join skew and high-cardinality grouping as performance risks.
• Explain schema evolution risks for crawlers, consumers, and downstream reports.

Security and governance

• Apply least privilege with IAM roles used by Glue jobs, crawlers, Lambda functions, and orchestration services.
• Distinguish identity-based policies, resource-based policies, bucket policies, and service roles.
• Explain how AWS KMS keys affect encrypted data access.
• Identify missing permissions from access denied symptoms.
• Secure S3 data with encryption, restricted public access, bucket policies, and scoped access.
• Explain how AWS Lake Formation can centralize data lake permissions.
• Recognize when column-level, row-level, or table-level access controls are relevant.
• Identify CloudTrail as a source for API activity auditing.
• Explain why network controls, VPC endpoints, and private connectivity may matter for data pipelines.

Operations, troubleshooting, and reliability

• Read job failure symptoms and identify whether the likely cause is IAM, schema, data quality, network, capacity, dependency, or code.
• Use CloudWatch logs and metrics as the first place to investigate managed job failures.
• Design retries without creating duplicate records.
• Explain idempotent writes and deterministic output paths.
• Use checkpoints, bookmarks, offsets, or watermarks to support incremental processing.
• Handle late-arriving data in streaming or event-driven pipelines.
• Route bad records to a quarantine location or dead-letter path.
• Plan a backfill from a raw immutable source.
• Separate monitoring for pipeline health, data quality, latency, freshness, and cost.

Data pipeline lifecycle checklist

Scenario and decision-point checks

Batch versus streaming

Athena versus Redshift versus Glue

S3 data lake layout

IAM and access troubleshooting

Performance troubleshooting

AWS Glue readiness checklist

Glue concepts

• Explain what the AWS Glue Data Catalog stores.
• Explain what a Glue crawler does and when not to rely solely on crawlers.
• Understand Glue jobs as managed ETL jobs.
• Understand Glue job bookmarks as a way to support incremental processing in supported scenarios.
• Identify the role of Glue connections for connecting to data stores.
• Recognize how Glue workflows or external orchestrators can sequence jobs.
• Know that Spark-based jobs may be affected by partitioning, skew, shuffles, and memory pressure.
• Identify where to look for Glue job logs and run history.

Glue job failure checklist

Minimal PySpark-style concepts to recognize

You do not need to memorize large code blocks, but you should understand the intent of common transform patterns:

## Conceptual pattern: read, filter, transform, write curated output
df = spark.read.parquet("s3://raw-zone/orders/")
clean = (
    df.filter("order_id IS NOT NULL")
      .dropDuplicates(["order_id"])
)
clean.write.mode("overwrite").partitionBy("order_date").parquet("s3://curated-zone/orders/")

Be ready to identify:

• What data is read and written.
• Whether the write mode is safe for the scenario.
• How partitioning affects downstream query pruning.
• Whether duplicate handling is correct for the business key.
• Whether overwrite could remove valid data if used incorrectly.

SQL and analytics readiness checks

Query patterns to recognize

• Filtering by partition columns to reduce scans.
• Aggregating by business dimensions and time windows.
• Joining fact and dimension data.
• Deduplicating with business keys and timestamps.
• Using window functions conceptually for latest-record selection.
• Understanding null handling and type casting.
• Distinguishing raw ingestion schema from curated analytics schema.

Example pattern:

WITH ranked_orders AS (
  SELECT
    order_id,
    customer_id,
    order_status,
    updated_at,
    ROW_NUMBER() OVER (
      PARTITION BY order_id
      ORDER BY updated_at DESC
    ) AS rn
  FROM curated_orders
)
SELECT order_id, customer_id, order_status, updated_at
FROM ranked_orders
WHERE rn = 1;

Can you explain:

• Why ROW_NUMBER() is used?
• What happens if updated_at is missing or duplicated?
• Whether the table should be partitioned by a date column for common queries?
• Whether this logic belongs in a curated table, a view, or a downstream report?

Data quality and validation checklist

Readiness prompts:

• Can you decide whether bad records should fail the pipeline or be quarantined?
• Can you design a retry that does not reload already accepted records?
• Can you explain how to alert on missing files or stale partitions?
• Can you identify whether validation belongs at ingestion, transformation, or consumption?

Orchestration and workflow checklist

Workflow decision path

    flowchart TD
	    A[New data or schedule] --> B{Single simple task?}
	    B -->|Yes| C[Trigger job or function directly]
	    B -->|No| D{Multiple dependencies or branches?}
	    D -->|Yes| E[Use workflow orchestration]
	    D -->|No| F[Use scheduled managed job]
	    E --> G{Failure handling needed?}
	    G -->|Yes| H[Add retries, alerts, quarantine, rollback or replay]
	    G -->|No| I[Still log status and outputs]

Security and governance checklist

IAM and permissions

Encryption and network controls

• Know where encryption at rest applies: S3, Redshift, databases, streams, logs, and intermediate outputs.
• Know why encryption in transit matters for service-to-service and client-to-service traffic.
• Recognize when KMS permissions are needed in addition to service permissions.
• Understand why private connectivity and VPC endpoints may reduce exposure to public network paths.
• Recognize that security groups and subnet routing can affect connectivity for jobs accessing data stores.
• Understand audit needs using CloudTrail, service logs, and access logs where applicable.

Governance prompts

• Which users can discover the dataset?
• Which users can query the dataset?
• Which users can access the underlying S3 objects?
• Are sensitive columns masked, tokenized, excluded, or restricted?
• Is access controlled consistently across Athena, Redshift, Glue, and other consumers?
• Are data retention and deletion expectations reflected in lifecycle or pipeline design?
• Can you prove who accessed or changed data-related resources?

Monitoring, logging, and operations checklist

Alerting checklist

• Job failure.
• Job duration exceeds expected range.
• Data volume anomaly.
• Missing partition or file.
• Data freshness breach.
• Excessive rejected records.
• Stream delivery failures.
• Query cost or scan-volume anomaly.
• Unauthorized access attempts or policy changes.

Cost and performance tradeoff checklist

Common weak areas and traps

Final-week review checklist

7 to 5 days before the exam

• Re-read the official AWS exam guide for AWS Certified Data Engineer – Associate (DEA-C01).
• Build a one-page service selection chart for ingestion, storage, processing, orchestration, and governance.
• Review IAM role assumptions, S3 bucket policies, and KMS access scenarios.
• Review Glue Data Catalog, crawlers, jobs, bookmarks, and troubleshooting.
• Practice distinguishing Athena, Redshift, Glue, EMR, Kinesis, Data Firehose, MSK, and DMS.
• Review data layout: raw/curated zones, file formats, compression, partitioning, and compaction.

4 to 2 days before the exam

• Work through mixed scenario questions, not just service flashcards.
• For every missed question, write the decision cue you failed to notice.
• Practice troubleshooting from symptoms: access denied, slow query, missing partition, duplicate output, schema mismatch.
• Review data quality patterns and where validation belongs.
• Review orchestration failure handling: retries, branching, alerts, backfills, and dead-letter paths.
• Review monitoring tools and what evidence each one provides.

Final 24 hours

• Skim this Exam Blueprint and mark any remaining weak areas.
• Review your own missed-question notes.
• Memorize no unsupported limits, dates, prices, or quotas.
• Focus on service selection logic and tradeoffs.
• Sleep instead of attempting to learn a new service from scratch.

Quick self-assessment table

Rate each area before you finish review.

If any row is still “Not ready,” spend your next study session on scenario questions for that area. If most rows are “Almost ready,” shift from reading to timed mixed practice and post-question review.