# AWS Certified Data Engineer - Associate (DEA-C01) Free Practice Exam and Practice Test

DEA-C01 · ASSOCIATE. Page: https://blowstack.com/practice-exams/aws-certified-data-engineer-associate

> Prepare for your AWS Certified Data Engineer - Associate exam with our practice exam simulator. Featuring real exam scenarios, detailed explanations, and instant feedback to boost your confidence and success rate.

Exam version DEA-C01: current, beta start Nov 27, 2023, release Mar 12, 2024. All exam dates: https://blowstack.com/tools/cloud-certifications/aws

## Exam at a glance

- Question bank: 891 practice questions
- Questions updated: 2026-10-30
- Free DEA-C01 practice exam (20 questions weighted by domain, in the exam simulator on this page, no sign-up): https://blowstack.com/practice-exams/aws-certified-data-engineer-associate
- DEA-C01 exam simulator (full-length or custom exams with explanations and a pass probability indicator): https://app.blowstack.com/practice-exams/configurator/aws-certified-data-engineer-associate
- Questions: 65
- Duration: 130 min
- Passing score: 72%
- Domains: 4
- Interactive DEA-C01 course (341 lessons built around exercises, no videos): https://blowstack.com/courses/aws-certified-data-engineer-associate
- Official DEA-C01 exam guide (the AWS document listing every domain, task and service in scope): https://docs.aws.amazon.com/aws-certification/latest/data-engineer-associate-01/data-engineer-associate-01.html

## DEA-C01 example questions

One example question per domain from the DEA-C01 question bank, with the correct answer and its explanation.

### Data Ingestion and Transformation

**Question:**

A company uses Amazon EventBridge Scheduler to start an AWS Glue ingestion job every night. Occasionally, the StartJobRun API request fails because of transient throttling, so the job never starts. The company wants failed delivery attempts to be retried for up to 1 hour and any request that remains undelivered to be retained in an Amazon SQS queue for investigation. The solution must not require custom code. An existing Scheduler execution role trusts scheduler.amazonaws.com and has permission to start the job and send messages to the queue. Which solution meets these requirements?

**Correct answer:** Keep the Glue StartJobRun target. Configure the schedule's retry policy with a maximum event age of 3,600 seconds and 185 retry attempts. Configure the SQS queue as the schedule's dead-letter queue.

**Explanation:** Scheduler's retry policy handles failures to invoke the target API. The maximum event age limits delivery retries to 1 hour, while the retry count permits repeated attempts with backoff. After delivery attempts are exhausted, Scheduler sends the undelivered event to the configured SQS dead-letter queue using the execution role.

### Data Store Management

**Question:**

A company stores temporary job-status records in an Amazon DynamoDB table with tenantId as the partition key and jobId as the sort key. Each record must expire 24 hours after creation. After expiration, records must become eligible for automatic deletion without scheduled cleanup jobs. Physical deletion can be delayed, but the application's Query requests must not return expired records. Which solution meets these requirements?

**Correct answer:** Store expiresAt as a Number containing the expiration time in Unix epoch seconds. Enable TTL on expiresAt, and add a Query filter expression that requires expiresAt to be greater than the current Unix epoch time in seconds.

**Explanation:** DynamoDB TTL requires a Number attribute containing an expiration timestamp in Unix epoch seconds. Deletion is asynchronous, so expired items can remain readable until DynamoDB deletes them. A Query filter that excludes expired records prevents those items from appearing in the application's results during that interval.

### Data Operations and Support

**Question:**

A company exposes reference datasets through an Amazon API Gateway REST API. An AWS Lambda function must retrieve data by calling GET /datasets/daily in the API's prod stage. The method uses AWS_IAM authorization, and API keys are not required.

The function signs its HTTPS requests correctly by using its execution role's temporary credentials. However, requests receive an authorization error. The execution role allows apigateway:GET, which lets the function retrieve API configuration, but has no other API Gateway permissions. The function and API are in the same AWS account, and no resource policies, permissions boundaries, service control policies, or explicit denies restrict access.

Which change will allow the function to retrieve the dataset while following least privilege?

**Correct answer:** Grant the execution role execute-api:Invoke on arn:aws:execute-api:<region>:<account-id>:<api-id>/prod/GET/datasets/daily.

**Explanation:** Calling a deployed API method is a data-plane operation authorized by execute-api:Invoke. Scoping the permission to the API, stage, HTTP method, and resource path permits only the required dataset request.

### Data Security and Governance

**Question:**

A company uses Amazon Athena to query an employee table in the AWS Glue Data Catalog. The table's Amazon S3 location is registered with AWS Lake Formation. An analyst IAM role currently has Lake Formation SELECT permission on the entire table and all required IAM permissions to run Athena queries. The role has no direct read access to the source S3 objects, and no other Lake Formation grants apply to the role.

A new security requirement allows analysts to query all columns except salary and national_id. Analysts must continue writing their own SQL against the existing table, without creating views or copying data. Which change will enforce this requirement with the least privilege?

**Correct answer:** Revoke the existing table-level SELECT permission. Grant the analyst role Lake Formation SELECT permission on only the columns other than salary and national_id.

**Explanation:** Lake Formation column-level SELECT permissions let Athena enforce access to the approved columns. Revoking the unrestricted grant removes the broader access that would otherwise allow analysts to query the sensitive columns.

## Free DEA-C01 cheat sheets

- [Domain 1: Data Ingestion and Transformation](https://blowstack.com/cheat-sheets/aws-certified-data-engineer-associate/dea-c01-domain-1.pdf) (34% of the exam, PDF)
- [Domain 2: Data Store Management](https://blowstack.com/cheat-sheets/aws-certified-data-engineer-associate/dea-c01-domain-2.pdf) (26% of the exam, PDF)
- [Domain 3: Data Operations and Support](https://blowstack.com/cheat-sheets/aws-certified-data-engineer-associate/dea-c01-domain-3.pdf) (22% of the exam, PDF)
- [Domain 4: Data Security and Governance](https://blowstack.com/cheat-sheets/aws-certified-data-engineer-associate/dea-c01-domain-4.pdf) (18% of the exam, PDF)

## Exam domains

The DEA-C01 questions are grouped into 4 domains divided into 17 tasks.

### Data Ingestion and Transformation (34% of the exam)

- Perform data ingestion
- Transform and process data
- Orchestrate data pipelines
- Apply programming concepts

### Data Store Management (26% of the exam)

- Choose a data store
- Understand data cataloging systems
- Manage the lifecycle of data
- Design data models and schema evolution

### Data Operations and Support (22% of the exam)

- Automate data processing by using AWS services
- Analyze data by using AWS services
- Maintain and monitor data pipelines
- Ensure data quality

### Data Security and Governance (18% of the exam)

- Apply authentication mechanisms
- Apply authorization mechanisms
- Ensure data encryption and masking
- Prepare logs for audit
- Understand data privacy and governance

## Exam mode and practice mode

| | Exam mode | Practice mode |
|---|---|---|
| Questions count | 65 | 1 - 75 |
| Time limit | 130 minutes | Optional, 10 - 200 minutes |
| Exam scope | 4 domains with the official questions ratio | Selected domains with the official questions ratio |
| Correct answers | After exam submission | After exam submission or after each answer |
| Question types | Single answer and multiple answer | Single answer, multiple answer or all types |
| Question hints | Never | Optional |
| Question domain | Revealed after exam submission | Revealed after submission or during the exam |
| Scoring | 15 of 65 questions do not count towards the result | Official AWS method or mathematical mean |

See all simulator features on the AWS Exam Simulator page: https://blowstack.com/practice-exams

## About the DEA-C01 exam

The AWS Certified Data Engineer - Associate (DEA-C01) exam is recognized as a demanding certification that validates a candidate's expertise in managing and optimizing data-driven workflows within the AWS ecosystem. While this exam is geared towards professionals with a background in data engineering, it is by no means an easy feat and requires a thorough understanding of both foundational and advanced AWS data services.

The DEA-C01 exam covers a broad range of topics, including but not limited to, data ingestion, transformation, storage, and visualization within AWS. Candidates must demonstrate a solid grasp of essential AWS data services such as Amazon Redshift, Glue, S3, and Kinesis, along with a deep understanding of how to architect and maintain scalable, secure, and high-performing data pipelines.

A critical component of the exam focuses on data processing frameworks like Apache Spark and Hadoop, as well as an understanding of database services, both relational (RDS, Aurora) and non-relational (DynamoDB). Additionally, the exam tests the candidate's ability to apply machine learning workflows using services like Amazon SageMaker within a data engineering context.

Security and compliance are integral to the exam, emphasizing the need for candidates to understand AWS's shared responsibility model and implement best practices for data governance, encryption, and access management. Services such as IAM, KMS, and AWS Lake Formation are frequently tested to ensure candidates can securely manage data at scale.

In this exam, candidates are also expected to distinguish between various data storage and retrieval solutions, optimizing them based on specific use cases and cost considerations. This includes knowing when to utilize services like S3 for unstructured data versus using Redshift for structured data analytics.

Overall, the questions in the DEA-C01 exam are designed to challenge both theoretical knowledge and practical application, with scenarios that require candidates to design, implement, and optimize complex data architectures. While the exam avoids overly complicated wording, the difficulty lies in the depth of knowledge requi

## Technologies and concepts

- **Access Control**: Access control turns security requirements into enforceable permissions for people, applications, and cloud services. It limits unauthorized activity while preserving legitimate operations, including the ability to deliver logs, run health checks, and investigate incidents.
- **ACID Transactions**: ACID properties help applications update shared data correctly despite concurrent requests, processing errors, and infrastructure failures. They apply to relational databases, some NoSQL operations, and transactional lakehouse tables, but their scope and isolation guarantees depend on the implementation.
- **Algorithmic Complexity**: Algorithmic complexity provides a way to compare algorithms and data structures by their growth in execution time, memory use, and other resources. In cloud data pipelines, these growth rates help engineers predict processing costs, identify scaling limits, and choose efficient transformations before adding more infrastructure.
- **Allowlisting**: Allowlisting establishes a known set of permitted choices rather than attempting to identify every unsafe choice. In cloud and AI governance, it helps prevent unauthorized access and shadow AI by connecting transparent approval decisions to enforceable access controls, documented usage conditions, and ongoing review.
- **Analytics**: Analytics turns raw records, events, and measurements into useful information through querying, aggregation, statistical analysis, and visualization. In the cloud, managed storage and processing services let engineers analyze changing data volumes without building every infrastructure component themselves.
- **API Versioning**: An API contract defines how clients send requests, interpret responses, and handle behaviors such as pagination and errors. Versioning allows incompatible contracts to coexist during migration, helping data pipelines remain reliable while producers and consumers change independently.
- **APIs**: An application programming interface defines available operations, accepted inputs, responses, and error behavior. In the cloud, APIs enable applications and automation tools to provision resources, configure services, and process data, making them the foundation of programmatic access.
- **At-Least-Once Delivery**: At-least-once delivery uses retries, acknowledgments, and durable buffering to favor delivery reliability over duplicate avoidance. It is common in real-time log ingestion, where consumers must tolerate repeated records without inflating metrics, duplicating alerts, or corrupting downstream state.
- **Attribute-Based Access Control**: ABAC expresses access rules using attributes such as project, department, environment, or data classification instead of maintaining separate permissions for every identity and resource. In cloud environments, trusted identity attributes and resource tags can make permissions scale with changing teams and infrastructure, provided attribute assignment and modification are tightly controlled.
- **Audit Logging**: Audit logging creates an evidence trail showing who or what performed an action, when it occurred, which resource was affected, and what the outcome was. In cloud environments, effective auditing requires selecting complementary log sources and protecting their delivery, retention, and accessibility across accounts, Regions, and workloads.
- **AWS SDKs**: An SDK turns application code into requests to cloud services, handling common tasks such as request signing, serialization, credential lookup, and response parsing. Engineers choose SDKs when service operations belong inside an application or custom automation, rather than in a graphical console, shell command, or infrastructure template.
- **AWS shared responsibility model**: AWS and its customers have distinct responsibilities for protecting systems, data, and operations, with the boundary changing according to the services used. Understanding that boundary helps engineers implement appropriate controls and collect the right evidence instead of assuming that AWS compliance certifications automatically make a workload compliant.
- **Backpressure**: Backpressure keeps data producers from overwhelming consumers, processing stages, or storage systems when incoming work exceeds available capacity. It helps pipelines remain stable during traffic bursts, throttling, and slow transformations, but requires explicit policies for buffering, retries, and overload.
- **Backward Compatibility**: Backward compatibility allows systems and data models to evolve without requiring every dependent component or historical record to change simultaneously. In data engineering, it is especially important when new processing code must read older datasets, schemas change across partitions, or applications share a database during a staged migration.
- **Batch Processing**: Batch processing separates data arrival from computation, allowing accumulated records to be ingested, transformed, or analyzed together. It is useful when throughput, efficient resource use, and complete datasets matter more than immediate results, such as hourly log aggregation or nightly financial reconciliation.
- **Broadcast Joins**: A broadcast join avoids repartitioning the larger dataset by distributing the smaller dataset to the workers processing it. This can reduce network shuffle and mitigate join-key skew, but the replicated input must fit safely within each worker's available memory.
- **Change Data Capture**: Change Data Capture (CDC) lets systems process incremental changes instead of repeatedly copying an entire dataset. It supports low-downtime migrations, continuously updated analytics, and current search or vector indexes, while requiring careful handling of ordering, retries, deletions, and recovery.
- **Checkpointing**: A checkpoint records enough information to recover a task without restarting all of its work, such as source positions, intermediate calculations, or an agent's workflow state. It reduces recovery time and repeated computation, but reliable recovery also depends on retained inputs, compatible state, and safe handling of repeated side effects.
- **CI/CD**: Continuous integration validates frequently merged code changes through automated builds and tests, while continuous delivery or continuous deployment automates the path toward production. Together, these practices shorten feedback cycles, make releases more repeatable, and reduce the risks associated with large, manually executed changes.
- **Classless Inter-Domain Routing (CIDR)**: CIDR defines how many leading bits identify an IP network and how many remain for addresses within that network. Engineers use it to size subnets, conserve address space, summarize routes, and prevent overlapping networks from disrupting cloud and hybrid connectivity.
- **Client-Side Encryption**: The receiving service stores ciphertext rather than the original plaintext, and authorized clients decrypt the data when they retrieve it. This separates access to stored data from access to its plaintext, but requires deliberate choices about key custody, application security, and recovery.
- **Columnar Storage**: Columnar storage places values from the same field together, reducing unnecessary data reads when queries inspect a small subset of columns across many records. It underpins analytical databases and file formats such as Apache Parquet and Apache ORC, often improving query performance and lowering storage and scan costs compared with row-oriented representations.
- **Concurrency Control**: When applications, ingestion jobs, and analysts access the same data simultaneously, their operations can interfere and produce incorrect results. Concurrency control uses mechanisms such as locks, version checks, and transaction isolation to prevent or detect these conflicts while balancing correctness, throughput, and latency.
- **Configuration Drift**: Configuration drift occurs when running infrastructure, operating systems, or applications no longer match their intended configuration, often because of manual changes, competing automation, or incomplete deployments. Detecting and managing drift helps engineers preserve security controls, reproduce environments, and investigate unexpected changes before they cause incidents.
- **Containers**: Containers provide a repeatable way to build, distribute, and run software across development and cloud environments. They improve deployment consistency and resource utilization, but require explicit controls for image security, runtime isolation, networking, identity, and persistent data.
- **Cost management**: In the cloud, cost management connects resource consumption and pricing choices to business outcomes. It helps engineers compare deployment options, eliminate waste, and balance spending against performance, availability, security, and operational effort.
- **Credential Management**: Credentials include passwords, access keys, session tokens, and other material used to prove an identity. Managing their lifecycle reduces credential theft, limits the impact of compromise, and keeps applications working when credentials change or expire.
- **Credential Rotation**: Passwords, access keys, tokens, and application secrets can be exposed through compromised systems, accidental disclosure, or excessive distribution. Rotation limits how long a persistent credential remains usable, but it must coordinate changes across the identity system, secret storage, and consuming applications to avoid outages.
- **Cron Expressions**: A cron expression tells a scheduler when to initiate work, such as ingesting files, running transformations, or refreshing metadata. Engineers must understand the scheduler’s syntax, time zone, and execution behavior because identical-looking expressions can behave differently across platforms.
- **Cross-Account Access**: Cloud accounts create administrative and security boundaries, but shared services, deployment pipelines, and operational teams often need controlled access across them. Cross-account access establishes that authorization without requiring shared credentials or moving resources into the same account.
- **Cryptographic Hashing**: A cryptographic hash function produces a deterministic fingerprint of data while making it computationally infeasible to reverse the digest or deliberately find different inputs with the same digest. In cloud systems, hashing supports file validation, digital signatures, and tamper detection, but it must be combined with trusted reference values and appropriate access or retention controls.
- **Data Cataloging**: A data catalog helps engineers discover datasets and determine whether they are appropriate for analytics, model training, evaluation, or retrieval. By documenting provenance, classifications, and usage restrictions, it supports trustworthy AI development, security reviews, and compliance without replacing access controls or data validation.
- **Data Classification**: Classification connects the value and risk of information to decisions about access, storage, monitoring, retention, and disposal. In cloud workloads, it helps engineers determine which activities require audit records, which changes should trigger alerts, and how quickly security teams must respond.
- **Data Compression**: Compression reduces the physical size of data by encoding it more efficiently, usually without losing information in engineering and analytics workloads. In cloud architectures, it can lower storage and query costs and improve transfer throughput, but it introduces processing overhead and must match the workload's access patterns.
- **Data Deduplication**: Duplicate records commonly arise from ingestion retries, overlapping extracts, source-system replication, and merging datasets. Deduplication improves analytical accuracy and machine learning data quality, but it requires explicit rules to distinguish redundant copies from legitimate repeated observations.
- **Data Durability**: Durability describes how reliably stored data survives hardware failures, corruption, and other failures covered by the storage system's design. It matters when selecting storage because data can remain safely preserved even when temporarily inaccessible, and different storage options protect against different failure scenarios.
- **Data Locality**: In cloud architectures, locality can mean using the same Region, Availability Zone, or processing environment, depending on the workload. It matters because network boundaries affect performance and billing, while replication and geographic distribution introduce trade-offs involving resilience, consistency, and data residency.
- **Data Masking**: Data masking reduces unnecessary exposure of confidential information in logs, messages, query results, and nonproduction datasets. It complements encryption and access control by limiting which sensitive values users and downstream systems can actually see.
- **Data Mesh**: Data Mesh distributes responsibility for analytical data to the teams that understand its business meaning, rather than making a central data team responsible for every dataset. It combines domain ownership, data as a product, self-service infrastructure, and federated computational governance to support scalable, controlled data sharing.
- **Data Partitioning**: Partitioning organizes data around access patterns, distribution requirements, and operational boundaries such as dates, tenants, or key ranges. A good strategy reduces unnecessary reads and enables parallel work, while a poor strategy creates skew, excessive metadata, small files, or overloaded database partitions.
- **Data Profiling**: Data profiling establishes what data actually contains before engineers transform, integrate, or use it for analytics, machine learning, or foundation model applications. Its findings guide cleansing decisions, validation rules, and monitoring thresholds, reducing the risk that inconsistent or unsuitable data reaches downstream consumers.
- **Data Provenance**: Data provenance connects a dataset to its sources, collection conditions, permissions, processing steps, and downstream uses. In AI systems, it helps engineers assess whether training and evaluation data are appropriate, investigate quality or bias issues, reproduce results, and explain the evidence behind model development.
- **Data Quality**: Data quality determines whether engineers can rely on data for analytics, application behavior, and AI training or inference. In secure data engineering, quality assessments work alongside privacy protections, access controls, and integrity checks to reduce unreliable outputs, unauthorized changes, and inappropriate use of sensitive information.
- **Data Representativeness**: Representative data provides appropriate coverage of the populations and situations an AI system will encounter, including relevant minority groups and uncommon but important cases. It supports reliable evaluation and responsible development by reducing coverage gaps that can hide poor performance or unequal outcomes.
- **Data Residency**: Data residency connects the physical location of data to legal, contractual, and organizational requirements. Cloud architectures must account for primary databases, replicas, backups, logs, and downstream systems because choosing a deployment Region alone does not establish compliance.
- **Data Retention**: Retention policies balance business needs, recovery requirements, legal obligations, privacy, and storage cost. In the cloud, engineers implement them through lifecycle rules, backup schedules, retention periods, deletion controls, and exceptions such as legal holds.
- **Data Skew**: Data skew occurs when some partitions contain substantially more records, larger records, or more expensive processing than others. It creates bottlenecks that can cause slow transformations, memory failures, streaming backlogs, and inefficient resource use even when overall cluster capacity appears sufficient.
- **Data Sovereignty**: In cloud architecture, data sovereignty influences where data can be stored and processed, who can access it, and whether it can cross jurisdictional boundaries. Engineers translate these obligations into Region selection, access controls, replication policies, and operational procedures rather than assuming that a particular hosting location guarantees compliance.
- **Data Validation**: Data validation determines whether data is suitable for its intended use by checking properties such as types, required values, uniqueness, relationships, and acceptable ranges. In cloud pipelines, it helps prevent defective records from contaminating analytics, operational systems, and machine learning datasets, while providing evidence for correction or controlled rejection.
- **Database Indexing**: An index organizes selected keys and references to records so a database can accelerate lookups, joins, range queries, and sometimes sorting. Effective indexing follows actual access patterns and balances faster reads against additional storage, write overhead, and operational maintenance.
- **Database Normalization**: Normalization separates facts into appropriately related tables so that each fact is maintained in a consistent place. It improves transactional data integrity, but it is distinct from log normalization, which standardizes event fields and formats so security tools can search and correlate records from different sources.
- **Deadlocks**: In a database deadlock, transactions hold locks that other transactions in the same cycle need, so none can proceed without intervention. Engineers prevent and recover from deadlocks through consistent lock ordering, short transactions, database deadlock detection, and safe retries, preserving correctness while managing concurrency.
- **Deduplication**: Duplicates arise when sources overlap, ingestion jobs replay data, producers retry delivery, or documents appear in multiple formats. Deduplication improves analytical accuracy and foundation model input quality while reducing unnecessary storage, processing, embedding, and retrieval work. Its correctness depends on distinguishing redundant copies from legitimate repeated events or meaningful versions.
- **Denormalization**: Denormalization shapes stored data around access patterns rather than minimizing duplication across separate entities. It can reduce joins, network requests, and repeated calculations, but increases storage, write amplification, and the effort required to keep duplicated values consistent.
- **Directed Acyclic Graphs**: A directed acyclic graph, or DAG, defines which tasks depend on others without allowing a dependency path to return to its starting task. In cloud data pipelines, DAGs help orchestrators run work in the correct order, execute independent tasks concurrently, and identify where failures block downstream processing.
- **Effective Permissions**: Assigned permissions do not necessarily equal usable access: authorization combines grants with organizational controls, resource policies, session restrictions, and request context. Understanding the resulting permissions helps engineers design least-privilege access and diagnose why an apparently allowed operation fails.
- **Elasticity**: Elasticity aligns available capacity with actual demand, adding resources during busy periods and releasing them when demand falls. In the cloud, automated provisioning and usage-based pricing can reduce idle capacity and avoid purchasing infrastructure for occasional peaks, while helping applications maintain performance.
- **Embeddings**: An embedding model maps inputs such as text or images into a vector space where related inputs are intended to have similar representations. Embeddings support semantic search, recommendations, clustering, and retrieval-augmented generation by helping applications find relevant information beyond exact keyword matches.
- **Encryption in Transit**: Encryption in transit prevents observers on a network path from reading protected data and, with correctly configured secure protocols, helps detect tampering and authenticate communicating endpoints. In cloud architectures, it applies to internet traffic, internal service communication, and hybrid or multi-cloud connections, independently of encryption at rest.
- **End-to-End Testing**: End-to-end testing checks whether an application achieves the intended user outcome when its components work together under realistic conditions. For foundation model applications, it evaluates the combined behavior of prompts, retrieval, models, tools, safeguards, and workflows rather than relying on model benchmarks alone.
- **Envelope Encryption**: Envelope encryption separates bulk data encryption from the protection and management of encryption keys. It combines efficient local encryption with centralized key controls, allowing cloud systems to protect large datasets without sending every byte through a key management service.
- **Ephemeral Storage**: Ephemeral storage holds disposable data such as caches, temporary files, and intermediate processing results. Its lifecycle is tied to a resource such as a virtual machine, container, or function execution environment, so applications must keep authoritative data elsewhere or be able to reconstruct it.
- **Event Correlation**: Individual logs and alerts often describe only fragments of an incident or operational failure. Event correlation combines those fragments into a contextual sequence, helping engineers detect suspicious behavior, investigate causes, and reduce duplicate or low-value alerts.
- **Event-Driven Architecture**: An event records something that has happened, such as an order being placed, a file being uploaded, or a monitoring threshold being crossed. By separating event producers from consumers, this architecture lets cloud applications process work independently, absorb traffic spikes, and deliver notifications without requiring every component to respond at the same time.
- **Evidence Integrity**: Reliable incident response depends on logs and other artifacts remaining authentic, traceable, and protected throughout collection, storage, transfer, and analysis. Evidence integrity combines tamper detection, preservation controls, and documented handling so engineers can reconstruct events and support defensible conclusions.
- **Exception Handling**: Data pipelines encounter malformed records, unavailable dependencies, permission errors, and unexpected program behavior. Exception handling separates failure paths from normal processing and makes recovery decisions explicit, helping engineers protect data integrity and operate reliable ingestion and transformation workloads.
- **Explicit Deny Precedence**: In a deny-overrides authorization model, a request fails whenever an applicable policy explicitly denies it, even if another policy allows it. This enables enforceable security guardrails, but troubleshooting requires identifying the denying statement and its evaluation context rather than simply adding permissions.
- **Exponential Backoff**: Exponential backoff gives an overloaded or temporarily unavailable dependency time to recover instead of receiving immediate repeated requests. In cloud systems, it is typically combined with randomized delays, retry limits, and safe request semantics to handle throttling and transient failures without amplifying an outage.
- **Fan-In**: Fan-in consolidates incoming data so that downstream systems can process, store, or analyze it through a common ingestion path. It simplifies integration but requires careful management of combined throughput, partitioning, ordering, retries, and downstream capacity.
- **Fan-Out**: Fan-out lets a producer trigger several independent activities without performing each activity itself. It supports parallel processing and independently scalable consumers, but requires deliberate handling of delivery failures, duplicate messages, ordering, and downstream capacity.
- **Fault Tolerance**: Fault-tolerant systems use redundancy, failure isolation, and automated handling of faults to keep component failures from becoming service failures. In the cloud, this capability also determines which workloads can safely use interruptible compute capacity and which need a more predictable capacity strategy.
- **Foundation Models**: Foundation models provide reusable capabilities for working with language, images, audio, and other data through prompting, retrieval, or additional training. Choosing between a foundation model and traditional task-specific machine learning depends on the workload, available data, explainability requirements, regulatory obligations, and operational constraints.
- **Generators**: A generator suspends execution after yielding a value and resumes when the consumer requests another value. In data engineering, generators support incremental ingestion and transformation, reducing intermediate memory usage when processing files, API results, or database records.
- **Graph Data Model**: Graph modeling emphasizes how entities connect, rather than organizing information primarily into rows or independent documents. It is useful for relationship-heavy workloads such as fraud investigation, recommendations, dependency analysis, and knowledge graphs, where questions require following connections across multiple entities.
- **Heterogeneous Migration**: Heterogeneous migration changes the database technology as well as moving the data, such as migrating from Oracle Database to PostgreSQL. It can support licensing changes, modernization, and adoption of managed cloud databases, but requires assessment of schema compatibility, application changes, and operational risk.
- **Hierarchical Navigable Small World (HNSW)**: HNSW organizes vectors into multiple layers of connected nodes so searches can navigate toward similar vectors without exhaustively comparing every stored vector. It supports semantic search, recommendations, and retrieval-augmented generation by trading additional index memory and construction work for low query latency and high recall.
- **High availability**: High availability reduces service interruptions by combining redundant components, isolated failure domains, health monitoring, and recovery mechanisms. In the cloud, it commonly involves distributing workloads across multiple Availability Zones so that a failure in one location does not stop the entire application.
- **High performance**: High performance depends on how effectively an application uses compute, memory, storage, and networking to deliver useful work. In the cloud, it requires measurable targets, appropriate resource choices, and continuous tuning rather than simply selecting larger instances.
- **Horizontal Scaling**: Instead of making one machine larger, horizontal scaling distributes work across multiple resources. It helps applications handle changing demand and can improve resilience, while requiring suitable workload distribution and state management. When automated to match demand, it provides elasticity.
- **Idempotency**: Idempotency makes retries safe when requests time out, events arrive more than once, or automation restarts after a failure. In incident response, it prevents repeated remediation attempts from creating duplicate resources, reversing containment, or causing additional disruption.
- **Incremental Loading**: Incremental loading reduces ingestion time, source-system load, data transfer, and processing cost by limiting each run to a defined set of changes. Reliable implementations combine change detection, durable progress tracking, and retry-safe target writes so that failures, updates, and late-arriving data do not produce gaps or duplicates.
- **Incremental Processing**: Incremental processing preserves useful results from previous runs and applies subsequent changes using tracked processing state. It reduces repeated scanning, transformation, and embedding work, but requires reliable change detection, replay-safe writes, and explicit handling of updates and deletions.
- **Infrastructure as code (IaC)**: IaC turns infrastructure definitions into repeatable deployment processes that can be reviewed, tested, and automated. It helps engineers create consistent environments, reduce manual errors, and apply security standards across accounts while maintaining a traceable history of changes.
- **Integration Testing**: Components that pass isolated tests can still fail when combined because of incompatible schemas, incorrect configuration, permissions, network restrictions, or unexpected dependency behavior. Integration testing exercises these boundaries before changes reach production, making it an important quality gate for application delivery and data pipeline deployment.
- **Inverted Index**: In text search, an inverted index maps each term to a posting list of documents containing it. In vector search, an inverted file index (IVF) applies a related organization by grouping vectors into partitions and searching selected partitions, trading exhaustive coverage for lower query cost.
- **JDBC**: JDBC gives applications and data-processing frameworks a common interface for accessing databases without implementing each database's native communication protocol. In cloud data engineering, it commonly connects ingestion and transformation jobs to relational sources and destinations, but successful operation still depends on compatible drivers, network access, authentication, and careful management of database load.
- **Joins**: A join connects related data, such as orders and customer profiles, to produce a dataset suitable for analysis or further processing. Correct joins require compatible keys, appropriate matching rules, and an understanding of how unmatched records and duplicate keys affect the result.
- **Key Custody**: Key custody separates possession of cryptographic material from permission to administer or use a key. It matters because key generation, storage, backup, revocation, and recovery choices determine both the confidentiality and the availability of encrypted data.
- **Key Management**: Encryption depends on keeping cryptographic keys protected while making them available to authorized systems. Key management defines who controls those keys, how applications use them, and how access is audited and recovered, supporting both encryption at rest and encryption in transit.
- **Key Rotation**: Key rotation limits how long a cryptographic key is used to protect new data and supports security policies, compliance requirements, and incident response. A safe rotation process directs new operations to fresh key material, retains older material when necessary for decryption or verification, and retires it only after its dependencies are resolved.
- **Key Salting**: A frequently occurring key can concentrate work on one partition, creating a bottleneck even when other workers have spare capacity. Key salting spreads that key's records across several derived keys, improving parallelism while requiring deliberate handling of joins, aggregations, and reads to preserve correctness.
- **Key-Value Data Model**: A key-value model organizes data as associations between identifiers and values rather than primarily as related tables. It is useful for access patterns such as retrieving a session, shopping cart, or user preference by identifier, and it underpins many cloud NoSQL databases and caches.
- **Lateral Movement**: After compromising a workload or identity, an attacker can exploit connectivity, credentials, and trust relationships to reach additional targets. Detecting this progression requires correlating network, DNS, identity, and workload activity rather than monitoring only traffic entering or leaving the environment.
- **Least privilege**: Least privilege reduces the damage that compromised credentials, software defects, and operational mistakes can cause. In cloud environments, it applies to identity permissions, workload roles, administrative access, network connectivity, and organizational guardrails, and requires ongoing review as requirements change.
- **Legal Holds**: A legal hold preserves information needed for litigation, investigations, or other legal obligations, usually without a predetermined expiration date. In cloud environments, engineers translate that obligation into enforceable storage and backup controls, supported by access restrictions, audit records, and reliable retrieval procedures.
- **Log Normalization**: Applications, operating systems, network devices, and cloud services describe events using different field names, formats, and meanings. Log normalization reconciles those differences so centralized detection rules and incident-response queries can operate across sources without repeatedly implementing source-specific logic.
- **Log Retention**: Log retention determines how long operational, security, and audit records remain available for monitoring, investigation, and compliance. An effective policy balances required history and retrieval speed against storage cost, privacy obligations, and protection from unauthorized alteration or deletion.
- **Management and governance**: Management handles activities such as provisioning, monitoring, configuration, and remediation, while governance defines who may act, which standards apply, and how compliance is demonstrated. Together, they help organizations give engineers useful autonomy without losing accountability, cost visibility, or control over risk.
- **Message Queuing**: A message queue buffers work between applications so that producers and consumers do not need to run at the same speed or be available simultaneously. This helps absorb traffic spikes and isolate failures, but requires careful handling of retries, duplicate messages, processing delays, and retention limits.
- **Missing Value Imputation**: Imputation addresses incomplete records without necessarily discarding them, using methods such as statistical estimates, domain rules, or predictive models. The chosen method affects distributions, analytical results, and model fairness, so engineers must validate both the replacements and the assumptions behind them.
- **Network Address Translation**: Network Address Translation allows workloads to communicate using addresses different from those assigned to their network interfaces. Cloud architectures commonly use it to give private workloads outbound IPv4 connectivity, conserve public addresses, or connect networks that require address remapping.
- **Null Handling**: Null handling defines how pipelines distinguish absent values from valid data and decide whether to retain, replace, reject, or quarantine affected records. It matters because inconsistent treatment of nulls can silently distort calculations, break joins, and allow incomplete data into downstream systems.
- **Open Database Connectivity (ODBC)**: ODBC separates application database-access calls from the driver that communicates with a particular database or query engine. It enables reporting tools, ingestion processes, and other applications to reuse a common connectivity interface, while still requiring source-specific drivers, authentication, networking, and SQL compatibility.
- **Optimistic Concurrency Control**: Optimistic Concurrency Control assumes conflicts are uncommon, so writers work without holding long-lived exclusive locks and check for conflicting changes at commit time. It prevents lost updates while supporting concurrent workloads, including multiple engines writing to an Apache Iceberg table in cloud object storage.
- **Output Validation**: Generative AI responses must be treated as untrusted data, even when they come from a trusted model endpoint. Output validation helps prevent unsafe content, sensitive-data disclosure, injection attacks, and unauthorized actions by checking responses at the boundaries where applications consume them.
- **Pagination**: Pagination lets applications consume or expose large collections without transferring every record in a single response. Correct implementations control resource usage while ensuring clients follow continuation information, handle failures, and understand how changing data affects completeness.
- **Partition Pruning**: Partitioned datasets divide data into groups using keys such as date, region, or tenant, and query engines use those boundaries to avoid reading irrelevant groups. Effective pruning depends on suitable partition design, usable query predicates, and accurate partition metadata, making catalog synchronization important for both performance and complete query results.
- **Predicate Pushdown**: A predicate is a condition that determines which rows qualify for processing, such as a date range or status comparison. Pushing supported predicates into a database, connector, or file reader can reduce data transfer, decoding, memory use, and downstream computation, improving ingestion and transformation runtime.
- **Privilege Escalation**: In cloud environments, an identity can gain unintended access without exploiting a software vulnerability: legitimate administrative APIs can become escalation paths when permissions are combined incorrectly. Preventing and investigating escalation requires evaluating effective authorization, identifying indirect paths to privileged identities, and correcting the permissions or trust relationships that enable them.
- **Prompt Templates**: A prompt template defines the repeatable parts of a model request, such as the task, context boundaries, examples, and expected response format, while leaving placeholders for request-specific data. Templates help engineers standardize application behavior, evaluate changes systematically, and reduce duplicated prompt-building logic without retraining the model.
- **Pseudonymization**: Pseudonymization reduces exposure of personal identifiers while preserving useful relationships between records for analytics, testing, and machine learning. Unlike anonymization, it retains a potential path to identification, so pseudonymized data still requires appropriate security controls and generally remains personal data under laws such as the GDPR.
- **Publish-Subscribe Messaging**: Publishers do not need to know which applications or people receive their messages, allowing producers and consumers to evolve independently. This pattern supports event distribution, application integration, and operational alerts, especially when one event must reach multiple independent recipients.
- **Query Federation**: A federated query engine presents remote data through a common query interface, translates supported operations for each source, and combines the results. This enables analysis across operational databases, warehouses, and data lakes while reducing ingestion requirements, but introduces dependencies on source performance, connectivity, permissions, and consistency.
- **Random Sampling**: Random sampling lets engineers inspect or analyze a subset of data while reducing systematic selection bias. It supports scalable data-quality assessment, but its usefulness depends on population coverage, sample size, and correct interpretation of uncertainty.
- **Rate Limiting**: Rate limiting protects shared resources by restricting traffic according to a measured request rate, an allowed burst, and an enforcement policy. At the cloud edge, it helps reduce application-layer abuse and backend overload, but effective policies must distinguish legitimate traffic spikes from harmful behavior.
- **Referential Integrity**: Referential integrity keeps relationships between datasets consistent, such as ensuring that every order references an existing customer. Relational databases can enforce these relationships with foreign-key constraints, while data lakes and analytical pipelines often require explicit validation rules to detect and handle broken references.
- **Repartitioning**: Distributed systems divide datasets into partitions that workers process in parallel, but uneven data distribution can leave some workers overloaded while others finish early. Repartitioning changes that distribution to improve execution efficiency, although effective skew mitigation requires choosing a suitable partitioning strategy rather than simply increasing the partition count.
- **Resiliency**: Resiliency combines failure isolation, redundant resources, controlled recovery, and operational testing to limit the impact of failures. In the cloud, it requires deliberate architecture across independent failure domains rather than assuming that provider-managed infrastructure makes an application immune to outages.
- **Resource Tagging**: Tags describe business and operational attributes such as ownership, department, cost center, application, and environment without changing a resource’s function. A consistent tagging strategy supports cost allocation and resource management, while policy controls help prevent missing, misleading, or unauthorized tags.
- **Resource Utilization**: Resource utilization shows how workloads consume CPU, memory, storage, network bandwidth, and other capacity. It informs rightsizing: selecting resource types, sizes, and quantities that meet performance and availability requirements without paying for unnecessary capacity.
- **REST**: REST separates clients from server implementations by defining how resources are identified, represented, and manipulated through a consistent interface, commonly using HTTP. In cloud architectures, it supports independently scalable API backends and interoperable clients, but resilience still requires deliberate timeout, retry, caching, and dependency design.
- **Retrieval-Augmented Generation**: RAG connects a foundation model to information outside its learned parameters, such as enterprise documents, product catalogs, or operational records. It helps applications answer questions using organization-specific or recently updated information without retraining the model, although accuracy still depends on retrieval quality and how the model uses the evidence.
- **Right-Sizing**: Right-sizing uses observed demand and application requirements to choose appropriate compute, memory, storage, and throughput capacity. It reduces waste while preserving performance and reliability, and it requires regular review as workloads change.
- **Role-Based Access Control**: Role-Based Access Control (RBAC) separates permission definitions from individual users or workloads, making access easier to administer and review. In cloud environments, it supports consistent authorization across teams and accounts, but requires carefully scoped roles and controlled assignments to prevent excessive privileges.
- **Schema Evolution**: Data schemas change as applications add fields, revise types, restructure records, or integrate new sources. Schema evolution defines how those changes are introduced, validated, and interpreted so that ingestion pipelines, transformations, tables, and downstream applications continue to work correctly.
- **Schema on Read**: Data can be stored in its original form and interpreted later using table metadata, parsing rules, and query expressions. This separates ingestion from analytical modeling, enabling flexible exploration while shifting responsibility for type compatibility, validation, and query efficiency to readers and processing pipelines.
- **Schema Validation**: A schema acts as a contract between data producers and consumers, making format expectations testable rather than implicit. Validating that contract at ingestion, transformation, and API boundaries catches incompatible data before it disrupts analytics, machine learning, or foundation model applications, but it does not establish factual accuracy or safety.
- **Semi-Structured Data**: Semi-structured data combines identifiable organization with flexible fields, nesting, and optional attributes, as commonly seen in JSON events and XML documents. It matters because cloud ingestion, analytics, and AI pipelines must preserve that flexibility while validating and transforming records into forms that downstream consumers can use reliably.
- **Serialization**: Serialization allows applications written in different languages and running on different systems to exchange data through an agreed format. In cloud data pipelines and foundation model integrations, correct serialization preserves data meaning and ensures that consumers receive the structure, types, and encoding they expect.
- **Serverless**: Serverless shifts infrastructure operations to the cloud provider so engineers can focus on application behavior, data, and configuration. It can reduce operational work and align costs with usage, but scaling behavior, billing, execution limits, and customer responsibilities vary by service.
- **Shared File Systems**: A shared file system lets applications on different servers work with the same files through familiar file operations rather than copying data between machines. In the cloud, managed file services support shared application content, user directories, and processing workloads while reducing the work of operating storage servers.
- **Slowly Changing Dimensions**: Dimension tables describe business entities such as customers, products, and locations whose attributes can change independently of transactional facts. Slowly Changing Dimensions (SCD) techniques control whether reports use current attributes or the attributes that were valid when an event occurred, preserving the historical meaning required by the business.
- **SQL Joins**: Joins connect related datasets, such as orders and customers, so engineers can enrich records, reconcile sources, and build analytical outputs. Correct joins require understanding key uniqueness, missing values, and output cardinality; efficient joins also require choosing execution strategies that fit the data and processing engine.
- **Star Schema**: Fact tables record business events or measurements at a defined level of detail, while dimension tables provide attributes used to filter, group, and interpret those facts. This structure makes analytical queries easier to understand and supports consistent reporting, but requires careful handling of historical changes, joins, and data quality.
- **Stateful and Stateless Filtering**: Stateful filters remember permitted traffic flows and use that context to recognize return traffic, while stateless filters evaluate each packet without remembering earlier exchanges. This distinction determines how engineers configure bidirectional access, troubleshoot blocked responses, and combine workload-level controls with subnet boundaries and inspection firewalls.
- **Stateful Processing**: Stateful processing uses remembered context, such as running totals, previously seen identifiers, or session history, when processing new data. It enables aggregation, deduplication, and event correlation, but requires explicit decisions about state storage, consistency, recovery, and expiration.
- **Statelessness**: A stateless component processes each request using information supplied with that request and, when necessary, state retrieved from external systems. This makes processing instances interchangeable, simplifying horizontal scaling, failure recovery, and deployment without requiring the overall application to stop storing data.
- **Static Analysis**: Static analysis evaluates artifacts against language rules, resource schemas, security checks, and organizational policies before changes reach production. In cloud engineering, it helps teams detect unsafe infrastructure definitions early and apply consistent deployment standards across accounts, although it cannot establish that deployed resources will behave securely in every environment.
- **Storage Tiering**: Storage tiering balances storage cost against access latency, retrieval charges, and retention requirements. Cloud platforms implement it through explicit storage-class selection, lifecycle policies, or automatic movement based on access patterns, helping engineers avoid paying premium storage rates for rarely used data.
- **Stratified Sampling**: The groups, called strata, are defined using attributes such as region, customer tier, source system, or transaction type. Sampling within each stratum helps engineers evaluate data quality across important segments instead of allowing large groups to dominate the results.
- **Structured Data**: Structured data commonly appears as records and tables containing values such as customer identifiers, transaction amounts, and timestamps. Its predictable organization makes it useful for querying, validation, analytics, and machine learning, but it does not automatically make the data accurate, labeled, or ready for model training.
- **Structured Logging**: Structured logs attach explicit context, such as severity, job identifiers, processing stages, and error codes, to each event. This makes distributed data pipelines easier to troubleshoot, query, monitor, and test without depending on fragile text parsing.
- **Temporary Credentials**: Temporary credentials let people and workloads access cloud resources without distributing permanent access keys. They reduce the lifetime of exposed credentials, support federation and role-based access, and shift credential renewal to identity services and supported client libraries.
- **Transaction Isolation**: Isolation is the ACID property that defines which effects of concurrent transactions can be visible before and after commit. Engineers choose isolation levels and concurrency controls to preserve business rules while balancing throughput, latency, blocking, and transaction retries.
- **Transport Layer Security**: TLS protects data while it moves between clients, load balancers, applications, and other resources. Effective protection requires more than enabling an encrypted listener: engineers must enforce acceptable protocol versions, validate identities, and protect every required network hop.
- **Tree Data Structures**: A tree represents relationships such as nested records, organizational hierarchies, and ordered indexes using nodes and edges. Understanding tree structure, traversal, and balancing helps engineers choose appropriate algorithms, process hierarchical data correctly, and reason about database performance.
- **Uniqueness Constraints**: Uniqueness constraints prevent multiple records from representing the same identity when the data model requires a single record. They protect joins, aggregations, and downstream processing from duplicate-driven errors, but their effectiveness depends on choosing the correct business key, comparison rules, and validation scope.
- **Unit Testing**: Unit tests check functions, methods, or small modules against explicit expectations using controlled inputs and dependencies. They provide fast feedback during development and help CI/CD pipelines reject regressions before code reaches deployed data, application, or machine learning workflows.
- **Unstructured Data**: Unstructured data contains information that typically requires interpretation or transformation before conventional analytics or machine learning can use it effectively. It matters because documents, conversations, photographs, and recordings provide signals that fixed database fields often do not capture.
- **Usage-Based Pricing**: Cloud costs are calculated from billable quantities such as instance runtime, stored data, requests, and data transfer rather than solely from an upfront infrastructure purchase. Understanding these meters helps engineers compare purchasing options, estimate total workload costs, and avoid paying for idle resources or unsuitable commitments.
- **Vector Search**: Embedding models represent text, images, audio, or other data as vectors whose relative positions can reflect meaningful relationships. Vector search uses these representations to find related content even when exact words differ, supporting semantic retrieval, recommendations, and retrieval-augmented generation.
- **Vectorization**: Vectorization replaces repeated scalar operations, such as interpreted loops over individual records, with operations on whole arrays, columns, or batches. In data ingestion and transformation pipelines, it can reduce runtime and compute cost by moving work into optimized libraries or execution engines, sometimes using CPU vector instructions.
- **Version Control**: Version control creates a traceable history for artifacts such as source code, infrastructure definitions, configuration, and AI prompts. It helps engineers collaborate safely, connect deployed behavior to specific revisions, and recover from changes that introduce errors or regressions.
- **Window Functions**: A window function evaluates a calculation over a defined set of rows associated with the current row, such as a customer's transactions or a product's daily sales. Engineers use these functions for rolling averages, running totals, rankings, deduplication, and comparisons between successive records without collapsing the data into grouped summaries.
- **Workload Identity**: Workload identity lets software prove who it is and receive permissions appropriate to its function and execution environment. Cloud implementations commonly combine runtime identity, federation, and short-lived credentials to reduce reliance on stored secrets while supporting least privilege and auditable access.

## Services on the exam

The 63 AWS services the DEA-C01 exam covers.

[Amazon API Gateway](https://blowstack.com/tools/cloud-services-hub/amazon-api-gateway), [Amazon AppFlow](https://blowstack.com/tools/cloud-services-hub/amazon-appflow), [Amazon Athena](https://blowstack.com/tools/cloud-services-hub/amazon-athena), [Amazon Aurora](https://blowstack.com/tools/cloud-services-hub/amazon-aurora), [Amazon Bedrock](https://blowstack.com/tools/cloud-services-hub/amazon-bedrock), [Amazon CloudWatch](https://blowstack.com/tools/cloud-services-hub/amazon-cloudwatch), [Amazon Data Firehose](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-data-firehose), [Amazon DataZone](https://blowstack.com/tools/cloud-services-hub/amazon-datazone), [Amazon DynamoDB](https://blowstack.com/tools/cloud-services-hub/amazon-dynamodb), [Amazon EC2](https://blowstack.com/tools/cloud-services-hub/amazon-ec2), [Amazon Elastic Container Service (Amazon ECS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-container-service-(amazon-ecs)), [Amazon Elastic File System (Amazon EFS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-file-system-(amazon-efs)), [Amazon Elastic Kubernetes Service (Amazon EKS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-kubernetes-service-(amazon-eks)), [Amazon EMR](https://blowstack.com/tools/cloud-services-hub/amazon-emr), [Amazon EventBridge](https://blowstack.com/tools/cloud-services-hub/amazon-eventbridge), [Amazon Kinesis Data Streams](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-data-streams), [Amazon Macie](https://blowstack.com/tools/cloud-services-hub/amazon-macie), [Amazon Managed Service for Apache Flink](https://blowstack.com/tools/cloud-services-hub/amazon-managed-service-for-apache-flink), [Amazon Managed Streaming for Apache Kafka](https://blowstack.com/tools/cloud-services-hub/amazon-managed-streaming-for-apache-kafka), [Amazon Managed Workflows for Apache Airflow (Amazon MWAA)](https://blowstack.com/tools/cloud-services-hub/amazon-managed-workflows-for-apache-airflow-(amazon-mwaa)), [Amazon MemoryDB for Redis](https://blowstack.com/tools/cloud-services-hub/amazon-memorydb-for-redis), [Amazon OpenSearch Service](https://blowstack.com/tools/cloud-services-hub/amazon-opensearch-service), [Amazon QuickSight](https://blowstack.com/tools/cloud-services-hub/amazon-quicksight), [Amazon RDS](https://blowstack.com/tools/cloud-services-hub/amazon-rds), [Amazon Redshift](https://blowstack.com/tools/cloud-services-hub/amazon-redshift), [Amazon S3](https://blowstack.com/tools/cloud-services-hub/amazon-s3), [Amazon S3 Glacier](https://blowstack.com/tools/cloud-services-hub/amazon-s3-glacier), [Amazon SageMaker](https://blowstack.com/tools/cloud-services-hub/amazon-sagemaker), [Amazon SageMaker Data Wrangler](https://blowstack.com/tools/cloud-services-hub/amazon-sagemaker-data-wrangler), [Amazon Simple Notification Service (Amazon SNS)](https://blowstack.com/tools/cloud-services-hub/amazon-simple-notification-service-(amazon-sns)), [Amazon Simple Queue Service (Amazon SQS)](https://blowstack.com/tools/cloud-services-hub/amazon-simple-queue-service-(amazon-sqs)), [Amazon VPC](https://blowstack.com/tools/cloud-services-hub/amazon-vpc), [AWS Backup](https://blowstack.com/tools/cloud-services-hub/aws-backup), [AWS Cloud Development Kit (AWS CDK)](https://blowstack.com/tools/cloud-services-hub/aws-cloud-development-kit-(aws-cdk)), [AWS CloudFormation](https://blowstack.com/tools/cloud-services-hub/aws-cloudformation), [AWS CloudTrail](https://blowstack.com/tools/cloud-services-hub/aws-cloudtrail), [AWS CodeBuild](https://blowstack.com/tools/cloud-services-hub/aws-codebuild), [AWS CodeCommit](https://blowstack.com/tools/cloud-services-hub/aws-codecommit), [AWS CodeDeploy](https://blowstack.com/tools/cloud-services-hub/aws-codedeploy), [AWS CodePipeline](https://blowstack.com/tools/cloud-services-hub/aws-codepipeline), [AWS Command Line Interface (AWS CLI)](https://blowstack.com/tools/cloud-services-hub/aws-command-line-interface-(aws-cli)), [AWS Config](https://blowstack.com/tools/cloud-services-hub/aws-config), [AWS Database Migration Service (AWS DMS)](https://blowstack.com/tools/cloud-services-hub/aws-database-migration-service-(aws-dms)), [AWS DataSync](https://blowstack.com/tools/cloud-services-hub/aws-datasync), [AWS Fargate](https://blowstack.com/tools/cloud-services-hub/aws-fargate), [AWS Glue](https://blowstack.com/tools/cloud-services-hub/aws-glue), [AWS Glue DataBrew](https://blowstack.com/tools/cloud-services-hub/aws-glue-databrew), [AWS IAM Identity Center (AWS Single Sign-On)](https://blowstack.com/tools/cloud-services-hub/aws-iam-identity-center-(aws-single-sign-on)), [AWS Identity and Access Management (IAM)](https://blowstack.com/tools/cloud-services-hub/aws-identity-and-access-management-(iam)), [AWS Key Management Service (AWS KMS)](https://blowstack.com/tools/cloud-services-hub/aws-key-management-service-(aws-kms)), [AWS Lake Formation](https://blowstack.com/tools/cloud-services-hub/aws-lake-formation), [AWS Lambda](https://blowstack.com/tools/cloud-services-hub/aws-lambda), [AWS Organizations](https://blowstack.com/tools/cloud-services-hub/aws-organizations), [AWS PrivateLink](https://blowstack.com/tools/cloud-services-hub/aws-privatelink), [AWS Resource Access Manager (AWS RAM)](https://blowstack.com/tools/cloud-services-hub/aws-resource-access-manager-(aws-ram)), [AWS Schema Conversion Tool (AWS SCT)](https://blowstack.com/tools/cloud-services-hub/aws-schema-conversion-tool-(aws-sct)), [AWS Secrets Manager](https://blowstack.com/tools/cloud-services-hub/aws-secrets-manager), [AWS Security Token Service (AWS STS)](https://blowstack.com/tools/cloud-services-hub/aws-security-token-service-(aws-sts)), [AWS Serverless Application Model (AWS SAM)](https://blowstack.com/tools/cloud-services-hub/aws-serverless-application-model-(aws-sam)), [AWS Step Functions](https://blowstack.com/tools/cloud-services-hub/aws-step-functions), [AWS Systems Manager](https://blowstack.com/tools/cloud-services-hub/aws-systems-manager), [AWS Tools and SDKs](https://blowstack.com/tools/cloud-services-hub/aws-tools-and-sdks), [AWS Transfer Family](https://blowstack.com/tools/cloud-services-hub/aws-transfer-family)

## Concepts on the exam

The 155 cloud concepts the DEA-C01 exam covers, each explained with the AWS services for it: https://blowstack.com/tools/cloud-concepts-hub?certification=aws-certified-data-engineer-associate

## Other practice exams

- [SAP-C03 AWS Certified Solutions Architect - Professional](https://blowstack.com/practice-exams/aws-certified-solutions-architect-professional)
- [SAA-C03 AWS Certified Solutions Architect - Associate](https://blowstack.com/practice-exams/aws-certified-solutions-architect-associate)
- [CLF-C02 AWS Certified Cloud Practitioner](https://blowstack.com/practice-exams/aws-certified-cloud-practitioner)
- [DOP-C02 AWS Certified DevOps Engineer - Professional](https://blowstack.com/practice-exams/aws-certified-devops-engineer-professional)
- [AIF-C01 AWS Certified AI Practitioner](https://blowstack.com/practice-exams/aws-certified-ai-practitioner)
- [AIP-C01 AWS Certified Generative AI Developer - Professional](https://blowstack.com/practice-exams/aws-certified-generative-ai-developer-professional)
- [MLA-C02 (beta) AWS Certified Machine Learning Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-machine-learning-engineer-associate)
- [SOA-C03 AWS Certified CloudOps Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-cloudops-engineer-associate)
- [SCS-C03 AWS Certified Security - Specialty](https://blowstack.com/practice-exams/aws-certified-security-specialty)
- [AIB-C01 (beta) AWS Certified AI Business Strategist](https://blowstack.com/practice-exams/aws-certified-ai-business-strategist)
- [ANS-C01 AWS Certified Advanced Networking - Specialty](https://blowstack.com/practice-exams/aws-certified-advanced-networking-specialty)
- [DVA-C02 AWS Certified Developer - Associate](https://blowstack.com/practice-exams/aws-certified-developer-associate)
