DVA-C02 · ASSOCIATE PRACTICE EXAM

AWS Certified Developer - Associate (DVA-C02) Free Practice Exam and Practice Test

399 DVA-C02 practice questions, updated , in an exam simulator that mirrors the real exam: its domains, its question types and its timing, with an explanation for every answer.

FREE PRACTICE EXAM20 questions · no sign-upStart the free practice exam
The DVA-C02 examretiring
Questions65
Duration130 min
Passing score72%
Domains4
ReleaseFeb 28, 2023 Last dayNov 30, 2026
Today
All exam dates →
EXAM GUIDEOfficial DVA-C02 exam guideThe AWS document listing every domain, task and service in scope.Open the guide →

DVA-C02 example questions

One example question per domain from the DVA-C02 question bank, with the correct answer and its explanation. Sign in to the simulator to answer them with all answer options.

Development with AWS Services

A developer configures an AWS Lambda function to use private subnets in a VPC so that it can call an internal inventory service. The function successfully calls the internal service, but calls to a third-party HTTPS API now time out. The third-party API is available only through a public IPv4 endpoint and does not support AWS PrivateLink. DNS resolution succeeds, and security groups and network ACLs allow the required traffic. The private subnet route tables contain only the VPC local route. The VPC also has a public subnet with a route to an internet gateway.

Which change will allow the function to call both services?

Show answerCORRECT ANSWER

Create a public NAT gateway with an Elastic IP address in the public subnet. Add a default IPv4 route to that NAT gateway in the route tables associated with the function's private subnets.

The public NAT gateway provides outbound IPv4 internet connectivity for the function's private addresses. The public subnet's internet gateway route completes the internet path. The existing VPC local route continues to carry traffic to the internal inventory service.

Security

A company is developing a multi-tenant mobile application. Users authenticate with an Amazon Cognito user pool. An administrator assigns each user a custom:tenantId attribute that app clients cannot modify. Several users belong to each tenant and must share access to that tenant's records.

Records are stored in one Amazon DynamoDB table with tenantId as the partition key and recordId as the sort key. The mobile application must call DynamoDB directly by using temporary AWS credentials. Users must be allowed to perform only GetItem and Query operations on their own tenant's records. The company wants to use a single IAM permissions policy for all tenants.

Which solution meets these requirements?

Show answerCORRECT ANSWER

Create a Cognito identity pool that trusts the user pool. Map custom:tenantId to a tenantId principal tag. Configure the authenticated role to accept session tags, and allow GetItem and Query on the table only when all dynamodb:LeadingKeys values equal ${aws:PrincipalTag/tenantId}.

The identity pool exchanges the authenticated user's token for temporary AWS credentials. Its attribute mapping carries the administrator-controlled tenant identifier into the role session as a principal tag. A ForAllValues:StringEquals condition on dynamodb:LeadingKeys restricts the permitted operations to the matching tenant partition. Users in the same tenant receive the same tenant tag and can share records without receiving access to other tenants.

Deployment

A team maintains a single AWS Lambda function. Its deployment pipeline must provide stable invocation ARNs for automated integration tests and production clients. While integration tests run, other builds can update the function's unpublished code. The tests must continue invoking exactly the candidate revision selected at the start of the test run, and production must remain unchanged. After approval, the pipeline must promote the tested revision and support rollback without uploading code again. Which solution meets these requirements?

Show answerCORRECT ANSWER

Publish a version for each candidate and maintain test and production aliases. Point the test alias to the candidate version and leave it unchanged during the tests. After approval, update the production alias to that version. Roll back by pointing the production alias to the previous version.

Published Lambda versions preserve immutable snapshots of function code and version-specific configuration. Aliases provide stable invocation ARNs that reference published versions. Keeping the test alias unchanged isolates the test run from updates to unpublished code. Updating the production alias promotes the tested version or restores a previous version without uploading code.

Troubleshooting and Optimization

A developer updates an Amazon API Gateway REST API to invoke the prod alias of an AWS Lambda function instead of the test alias. After the API is redeployed, requests return HTTP 500. API Gateway execution logs report "Invalid permissions on Lambda function," and no invocations reach the prod alias. The API uses Lambda proxy integration without an IAM credentials role. Clients are authorized to invoke the API. The Lambda resource-based policy permits apigateway.amazonaws.com to invoke only the test alias, and no explicit deny policies apply.

Which change should the developer make to resolve the integration failure while maintaining least-privilege access?

Show answerCORRECT ANSWER

Add a resource-based permission to the prod alias that allows apigateway.amazonaws.com to perform lambda:InvokeFunction, with a SourceArn condition restricted to the intended API stage, method, and resource.

API Gateway needs permission to invoke the alias ARN targeted by the integration. The permission on the test alias does not authorize invocation of the prod alias. An alias-specific resource-based permission with a restricted API execution SourceArn grants the required access without unnecessarily broadening it.

Free DVA-C02 cheat sheets

One PDF per exam domain: the domain's task statements, each drawn with its services and exam traps, then the concepts and core services to remember.

Exam domains

The DVA-C02 questions are grouped into 4 domains divided into 13 tasks.

Development with AWS Services32%
3 tasks · 6 in the free practice exam
  • Develop code for applications hosted on AWS
  • Develop code for AWS Lambda
  • Use data stores in application development
Security26%
3 tasks · 5 in the free practice exam
  • Implement authentication and/or authorization for applications and AWS services
  • Implement encryption by using AWS services
  • Manage sensitive data in application code
Deployment24%
4 tasks · 5 in the free practice exam
  • Prepare application artifacts to be deployed to AWS
  • Test applications in development environments
  • Automate deployment testing
  • Deploy code by using AWS Continuous Integration and Continuous Delivery (CI/CD) services
Troubleshooting and Optimization18%
3 tasks · 4 in the free practice exam
  • Assist in a root cause analysis
  • Instrument code for observability
  • Optimize applications by using AWS services and features

Exam mode and practice mode

Exam modePractice mode
Questions count651 - 75
Time limit130 minutesOptional, 10 - 200 minutes
Exam scope4 domains with the official questions ratioSelected domains with the official questions ratio
Correct answersAfter exam submissionAfter exam submission or after each answer
Question typesSingle answer and multiple answerSingle answer, multiple answer or all types
Question hintsNeverOptional
Question domainRevealed after exam submissionRevealed after submission or during the exam
Scoring15 of 65 questions do not count towards the resultOfficial AWS method or mathematical mean

See all simulator features on the AWS Exam Simulator page.

About the DVA-C02 exam

The AWS Certified Developer - Associate certification is challenging due to its comprehensive coverage of AWS services and its focus on the practical application of development principles within the AWS ecosystem. This certification tests your ability to design, develop, and deploy cloud-based applications on AWS, requiring a solid understanding of core AWS services and best practices for development and architecture.

 

The certification exam emphasizes an understanding of key AWS services such as EC2, S3, DynamoDB, Lambda, API Gateway, RDS, and others. You need to know how these services work, how to configure them, and how to integrate them into applications.

 

You have to be able to solve real-world problems, including designing scalable and resilient applications, troubleshooting issues, and optimizing performance and cost. Understanding deployment and monitoring practices is also essential, including familiarity with CI/CD (Continuous Integration and Continuous Deployment) pipelines using AWS services like CodeCommit, CodeBuild, CodeDeploy, and CodePipeline.

 

Security is another critical aspect. Candidates must know how to implement security best practices, including identity and access management, encryption, and securing data in transit and at rest. They should be able to use IAM roles and policies effectively to secure their applications.

 

The certification also requires knowledge of AWS's global infrastructure, including regions and availability zones, and how to design applications that take advantage of this infrastructure for high availability and fault tolerance.

Furthermore, the exam demands familiarity with microservices architecture and the ability to implement serverless applications using AWS Lambda and other related services. This involves understanding the benefits and challenges of microservices and how to manage them on AWS.

 

The AWS Certified Developer - Associate certification is far more challenging than the AWS Certified Cloud Practitioner because it requires a comprehensive understanding of AWS services and the ability to apply best practices in security, architecture, and deployment. However, it is considered easier than the AWS Certified Solutions Architect - Associate because it encompasses a shorter exam scope.

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.

Anomaly Detection

Anomaly detection compares observed activity with an established baseline, statistical model, or expected pattern to identify unusual behavior. In cloud security, it helps engineers detect potentially compromised identities, unexpected network activity, and abnormal resource usage that fixed rules alone might miss. An anomaly is evidence for investigation, not proof of an attack.

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.

Asymmetric Encryption

Asymmetric encryption lets senders protect data without sharing a secret decryption key with the recipient. In cloud applications, it is useful for protecting small secrets and exchanging symmetric encryption keys while keeping private-key operations inside controlled services or hardware security modules.

Asynchronous Communication

Applications exchange messages, events, or job requests and obtain results separately through polling, callbacks, or notifications. This decouples components and helps absorb traffic bursts, but requires explicit handling of delivery failures, duplicate processing, and delayed results.

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.

Authentication

Cloud systems use authentication to establish which identity is making a request by validating credentials or other evidence. It is distinct from authorization, which determines what that identity may do, and is essential for protecting administrative access, application data, and service-to-service communication.

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.

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.

Backup and Restore

Backups preserve earlier states of data so engineers can recover from accidental deletion, application errors, ransomware, or infrastructure failures. Effective protection requires more than creating copies: it also requires suitable retention, protected access, and tested restoration procedures that meet business recovery objectives.

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.

Batching

Batching spreads fixed overhead across multiple items instead of handling every item independently. It can reduce request costs and improve ingestion throughput, but introduces buffering delays and requires careful handling of failures, retries, and resource limits.

Blue-Green Deployment

Two independently deployable environments allow engineers to validate a replacement release while the existing release continues serving users. Switching traffic rather than modifying the live environment reduces deployment disruption and can enable fast rollback, provided data and dependencies remain compatible.

Cache-Aside

Also called lazy loading, cache-aside stores data in the cache only when an application requests it. It can reduce read latency and database load, but the application must manage cache population, expiration, invalidation, and failure handling.

Caching

A cache serves repeated requests without always accessing the original data source or recomputing a result. In cloud architectures, caching can reduce latency, origin load, and data transfer, but it requires deliberate decisions about freshness, capacity, security, and failure behavior.

Canary Deployment

A canary deployment runs the current and candidate versions concurrently, exposing only a limited share of real requests or users to the candidate. Engineers use production metrics and explicit acceptance criteria to decide whether to promote the candidate or redirect traffic to the stable version, reducing the impact of faulty releases.

Capacity Planning

Capacity planning translates expected traffic, data growth, and processing requirements into measurable resource needs. In the cloud, it combines forecasting, benchmarking, scaling policies, service quota management, and failure testing because elastic infrastructure is neither unlimited nor instantaneous.

Certificate management

It covers certificate issuance, validation, deployment, renewal, revocation, and retirement, together with protection of the keys and trust chains that make certificates useful. In cloud environments, effective certificate management prevents outages from expired certificates and supports authenticated, encrypted communication across public endpoints, internal services, accounts, and Regions.

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.

Choreography

In choreography, a business process emerges from interactions among autonomous services rather than from instructions issued by one coordinator. It supports loosely coupled, independently scalable applications, but requires deliberate handling of message delivery, partial failures, and end-to-end visibility.

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.

Circuit Breaker

A circuit breaker tracks dependency failures and stops sending requests when a configured threshold is exceeded, preventing repeated failures from exhausting caller resources. It supports fast failure, graceful degradation, and controlled recovery, making it useful for foundation model invocations, agent tools, and other remote services.

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.

Code Coverage

Code coverage identifies which parts of a program a test suite exercises and which remain untested. In CI/CD pipelines, coverage reports and enforceable thresholds help teams detect testing gaps before deployment, but coverage alone does not prove that software behaves correctly.

Concurrency

Concurrent tasks can execute simultaneously or take turns using shared resources while other tasks wait for input, output, or dependencies. In cloud applications, understanding concurrency helps engineers size capacity, improve throughput, protect downstream systems, and diagnose throttling or resource contention.

Configuration Management

Configuration management makes infrastructure and application settings repeatable, auditable, and easier to recover when changes cause problems. In the cloud, it is a shared responsibility: the provider configures its underlying infrastructure, while customers manage the settings and software within their control.

Confused Deputy Problem

A service or application can authenticate a request correctly yet misuse its own permissions because it fails to verify whose authority the request should exercise. Cloud defenses bind delegated access to the intended customer, source resource, and operation rather than trusting the intermediary’s identity alone.

Connection Pooling

Establishing connections consumes time and resources through network handshakes, authentication, and server-side session creation. A connection pool amortizes those costs across requests and can limit concurrent access to a backend, improving efficiency when its capacity and timeout settings match the workload.

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.

Content-Based Routing

Instead of distributing requests solely by availability or load, content-based routing selects a destination suited to each request’s characteristics. In generative AI applications, it can match tasks to specialized foundation models while balancing quality, latency, cost, and security constraints.

Contract Testing

A contract defines the externally observable behavior that a consumer expects from a provider, including data formats, required fields, status codes, and relevant interaction rules. Contract tests catch incompatible changes early and make mocked dependencies more trustworthy, reducing reliance on slow or fragile end-to-end tests.

CPU Architecture

CPU architecture affects software compatibility, execution performance, and the cost of running workloads in the cloud. Choosing compute resources requires matching the processor architecture, instance family, and instance size to application requirements rather than comparing virtual CPU counts alone.

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 Provider Chain

A credential provider chain separates application code from the mechanism used to obtain authentication credentials. It lets the same application use a developer profile locally and a workload identity in production, but its precedence rules must be understood to prevent unintended credentials from overriding the intended identity.

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.

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.

Data Anonymization

Data anonymization reduces the risk of identifying people from datasets, including through combinations of attributes or linkage with external information. In cloud analytics and AI systems, it helps protect sensitive training data, prompts, retrieved documents, and outputs, but requires more than simply removing names.

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 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 Minimization

Data minimization reduces privacy exposure by limiting the amount, sensitivity, and detail of information used throughout a system’s lifecycle. In cloud and AI architectures, it helps engineers preserve useful functionality while reducing unnecessary disclosure, storage, and downstream use of personal or confidential information.

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 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.

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.

Dependency Pinning

Dependency pinning replaces floating dependency selections with controlled references recorded in manifests, lockfiles, or build configuration. It improves artifact consistency, troubleshooting, and rollback, but requires deliberate updates to incorporate security fixes and compatibility changes.

Deployment Rollback

Rollback limits the impact of a faulty release by returning workloads to a known-good deployment state. It depends on preserved artifacts, compatible dependencies and data, reliable failure signals, and a tested recovery procedure rather than simply undoing a source-code change.

Distributed Tracing

A distributed trace connects individual operations across services into a single view of a request's execution. It helps engineers troubleshoot cloud applications whose behavior cannot be understood from one server's logs or metrics alone.

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.

Encryption at Rest

Encryption at rest protects data stored in objects, disks, databases, snapshots, and backups from disclosure when the underlying storage is accessed without the required keys. In cloud environments, it combines storage encryption with key management and access controls, but it does not replace authorization, backups, or encryption in transit.

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.

Environment Isolation

Environment isolation establishes boundaries around application infrastructure, identities, configuration, and data throughout the delivery lifecycle. It lets teams test and deploy changes without exposing production systems to unnecessary access, accidental modification, or disruptive workloads.

Environment Variables

Environment variables separate deployment-specific settings, such as resource names and logging levels, from application logic. Cloud platforms commonly inject them when starting functions or containers, allowing the same deployment artifact to run in multiple environments while keeping configuration explicit and manageable.

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 Streaming

Producers append events to a stream, while consumers read and process those events independently, often within seconds or less. This decouples event generation from downstream processing and supports incident detection, operational analytics, and automated responses without requiring producers to know every consumer.

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.

Eventual Consistency

A successful write does not necessarily become visible immediately through every replica or read path. This model supports asynchronous replication and scalable reads, but engineers must account for stale results, replication lag, and possible data loss when failing over to an asynchronous replica.

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.

Exit Codes

By convention, an exit code of zero indicates success, while a nonzero value indicates an error or another condition defined by the program. CI/CD pipelines use these values to evaluate automated tests, enforce deployment gates, and interpret health-check results, making correct propagation essential to reliable automation.

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.

Externalized Configuration

Applications obtain settings from deployment inputs, environment variables, configuration files, or configuration services instead of hard-coding them into business logic. This enables artifact reuse across environments and independent configuration changes, but requires validation, access control, and explicit rules for when applications load updated values.

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 Isolation

Cloud systems use fault isolation to limit the scope of infrastructure failures, software defects, and resource exhaustion. Separating components into independent failure domains reduces correlated outages, but applications also need healthy alternatives and recovery mechanisms to remain available.

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.

Feature Flags

Feature flags separate deploying software from releasing its functionality to users. They help engineers configure environments, expose changes gradually, and disable problematic behavior, but require careful validation, testing, and lifecycle management.

Gitflow

Gitflow uses long-lived production and integration branches alongside temporary feature, release, and hotfix branches. It helps teams coordinate scheduled releases and map version-control events to CI/CD pipelines, but adds merge overhead and requires explicit rules for promoting tested artifacts between environments.

Graceful Degradation

Instead of allowing a failed dependency or overloaded component to make an entire application unavailable, graceful degradation provides a predefined, safe reduced-service mode. In AI applications, this can mean switching to an approved alternative model, returning authorized cached information, or offering search results without generating an answer.

Health Checks

Health checks turn observations about infrastructure and applications into signals for traffic routing, deployment decisions, and automated recovery. Their value depends on testing the right behavior and connecting failures to appropriate actions without causing unnecessary restarts or cascading outages.

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.

Identity Federation

Federation separates where an identity is authenticated from where that identity accesses resources, using established trust and verifiable identity assertions or tokens. It enables centralized sign-in for employees, customers, and workloads while letting each application or cloud account retain control over authorization.

Immutable Infrastructure

Changes to operating systems, application dependencies, and security configuration are built into tested machine or container images and deployed as replacements. This reduces configuration drift and makes recovery more repeatable, provided that persistent data, secrets, and incident evidence are managed separately.

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.

Input Sanitization

Input sanitization reduces the risk that user submissions, retrieved documents, or tool responses introduce malicious instructions or executable payloads into an application. In generative AI systems, it works alongside validation, prompt-injection detection, content filters, and authorization controls rather than making arbitrary text inherently safe.

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.

IP Routing

IP routing determines how traffic moves between subnets, private networks, and the internet. In cloud environments, understanding routes, subnet associations, and gateways is essential for designing connectivity and diagnosing why a workload can or cannot reach a destination.

JSON

JSON, short for JavaScript Object Notation, is widely used to exchange application data and store semi-structured records such as events, logs, and API responses. In machine learning pipelines, it preserves nested information during ingestion, but its parsing overhead and lack of columnar storage affect whether it is suitable for repeated analytical reads.

JSON Web Tokens

A JSON Web Token (JWT) carries claims about a subject, its issuer, and its validity, allowing an API to evaluate a request without retrieving a server-side session for every call. Secure use requires verifying the token and enforcing authorization rules; merely decoding its contents does not establish trust.

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 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.

Latency

Latency measures delay rather than how much work a system completes per second. In cloud data pipelines, it determines how quickly ingested data becomes useful, so architecture and capacity must match business deadlines for processing, delivery, and freshness.

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.

Load Testing

Load testing applies representative traffic or work to an application and measures whether it meets business performance requirements. In cloud environments, it helps engineers identify bottlenecks, validate automatic scaling, and prevent performance regressions through repeatable CI/CD tests.

Log Levels

Applications assign levels such as DEBUG, INFO, WARN, and ERROR to log events, while logging configuration determines which events are emitted or retained. Consistent levels make application behavior easier to understand, reduce unnecessary logging costs, and help engineers identify failures without losing useful operational context.

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.

Loose Coupling

Loosely coupled components communicate through explicit contracts rather than depending on each other's internal implementation, deployment, or execution timing. This supports independent scaling and fault isolation, but requires deliberate handling of message delivery, data consistency, interface evolution, and operational visibility.

Message Ordering

Message ordering ensures that related events are delivered or processed in the sequence required by an application. It matters when later actions depend on earlier ones, such as applying account transactions, updating inventory, or reconstructing device state from a stream.

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.

Metric Cardinality

A metric such as request latency becomes many separate time series when it is partitioned by service, environment, endpoint, or instance. Controlling cardinality preserves useful diagnostic detail while limiting ingestion volume, storage costs, query work, and operational complexity.

Microservices and component delivery

Microservices divide an application into services organized around business capabilities, while component delivery provides the processes and automation needed to release those services safely. This approach supports independent team ownership and targeted scaling, but introduces distributed-system complexity and requires disciplined interface design, observability, and deployment practices.

Mocking

Mocking lets engineers define how dependencies respond and verify how application code interacts with them without contacting live systems. It makes unit tests fast and repeatable, especially for cloud applications that depend on databases, queues, APIs, and other managed services.

Monolithic Architecture

A monolithic application combines capabilities such as request handling, business logic, and data access within one deployment boundary. This can simplify development, testing, and operations, but it couples releases and typically requires scaling the whole application rather than individual business capabilities.

Mutual TLS

Ordinary HTTPS typically authenticates only the server, whereas mutual TLS also requires the client to prove its identity using a certificate and its corresponding private key. This helps cloud workloads reject untrusted peers, but it requires certificate lifecycle management and separate authorization policies.

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.

OAuth 2.0

OAuth 2.0 separates the application requesting access, the server issuing tokens, and the API enforcing permissions. In cloud applications, it enables scoped API access for users and workloads, but bearer tokens must be protected because possession is generally sufficient to use them.

OpenID Connect

OpenID Connect (OIDC) standardizes authentication and identity claims so applications can rely on a shared identity provider instead of managing separate credentials. In cloud environments, it supports application sign-in and identity federation, including exchanges of trusted workload tokens for temporary cloud credentials.

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.

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.

Performance Benchmarking

Performance benchmarking establishes how quickly, reliably, and efficiently an application handles a specified workload. In cloud delivery pipelines, it helps engineers detect performance regressions, validate scaling behavior, and compare deployment options before promoting a release.

Performance Profiling

Performance profiling connects observed latency, throughput, and resource consumption to the code paths and dependencies responsible for them. For cloud and generative AI applications, it helps engineers distinguish application inefficiencies from model inference delays, network waits, throttling, and infrastructure limits before making changes.

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.

Public Key Infrastructure

Public Key Infrastructure (PKI) allows systems to verify that a public key belongs to the expected server, user, device, or organization. In cloud environments, it supports authenticated TLS connections, mutual TLS, and digital signatures while requiring careful protection of private keys and management of certificate lifecycles.

Public-Key Cryptography

A public key can be distributed, while its corresponding private key must remain secret and under its owner's control. This separation enables cloud systems to authenticate servers and users, establish encrypted connections, and verify signed data without sharing a single secret with every participant.

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.

Quality Gates

A quality gate turns testing, evaluation, and operational requirements into enforceable promotion criteria. In cloud delivery, gates prevent unacceptable application, infrastructure, or generative AI changes from reaching broader environments while providing an auditable explanation for each release decision.

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.

Regression Testing

Regression testing reruns a maintained set of tests after changes and compares results with approved expectations or a trusted baseline. For generative AI applications, it helps detect unintended changes in answer quality, safety, tool use, latency, and cost when prompts, models, retrieval data, or application code change.

Regular Expressions

Regular expressions let engineers recognize variable text without enumerating every possible value. In cloud operations, they help locate failures, extract fields from unstructured logs, and select events for monitoring or forwarding, but their syntax and capabilities depend on the system evaluating them.

Relational Data Model

The relational data model provides a structured way to represent entities, their attributes, and their relationships while supporting integrity rules and flexible queries. It is commonly implemented by SQL database systems and is useful when applications need consistent records, joins across entities, and reliable transactional updates.

Reproducible Builds

Reproducible builds control dependencies, toolchains, environment settings, and packaging behavior so that rebuilding a release produces the same artifact bytes. They help engineers detect unexpected changes, investigate software supply-chain risks, and generate dependable deployment artifacts, but require more than simply rerunning a successful CI job.

Request Signing

A client calculates a signature from selected request details and credential material, and the receiving service verifies that signature before processing the request. In cloud applications, this enables authenticated API calls without transmitting the secret signing key, while authorization policies separately determine which operations the caller may perform.

Request Validation

Request validation determines whether incoming data has the required structure, types, values, and application-specific meaning. In cloud systems, it helps reject malformed or unsupported requests early, protect downstream capacity, and give clients predictable feedback without replacing authentication, authorization, or content safety controls.

Resource Efficiency

Resource efficiency means matching cloud capacity and architecture to useful work rather than provisioning for assumptions or leaving resources idle. It helps engineers improve performance per resource, control costs, and reduce environmental impact while preserving security and reliability requirements.

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.

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.

Rolling Deployment

A rolling deployment gradually updates or replaces running instances, tasks, or pods instead of changing the entire fleet at once. It limits simultaneous disruption and can avoid maintaining a complete second environment, but requires sufficient capacity, reliable health checks, and compatibility between application versions.

Row-Level Security

Row-level security allows multiple users or tenants to share tables and dashboards while seeing only the records they are authorized to access. It combines identity or trusted session attributes with data attributes, such as tenant, department, or region, to enforce access without maintaining separate datasets for every audience.

SAML 2.0

Security Assertion Markup Language 2.0 enables users to access cloud accounts and applications using an existing organizational identity rather than separate credentials for each destination. It supports centralized authentication and single sign-on, while the receiving service remains responsible for deciding what the user can access.

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.

Self-Signed Certificates

A self-signed certificate binds an identity to a public key without providing independent verification of that identity. It is useful for development and controlled environments, but clients must explicitly trust it to authenticate connections securely.

Separation of Concerns

Each component focuses on a specific responsibility, such as presentation, business rules, data storage, or message delivery, rather than combining unrelated work. This makes systems easier to change, test, secure, and scale, while reducing the impact that changes or failures in one area have on others.

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.

Server-Side Encryption

Server-side encryption protects stored data while allowing applications to use normal storage and database operations. Its security depends on the service’s encryption boundary, access controls, and key-management configuration, not merely on whether encryption is enabled.

Service Level Indicators

A Service Level Indicator (SLI) measures an aspect of service behavior, such as successful request rate, response latency, or data freshness. Selecting SLIs from business requirements helps engineers evaluate availability, detect user-impacting failures, and determine whether resilient architecture investments deliver the intended results.

Session Affinity

Session affinity helps applications that keep session data or useful cached context on individual backend servers. It can simplify support for stateful applications, but it can also create uneven load and does not preserve session data when a backend fails.

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.

Strong Consistency

Strong consistency lets applications read current data after a write succeeds, rather than temporarily receiving an older value from a lagging replica. It matters when stale information could cause incorrect decisions, but it does not replace transactions, conditional updates, or concurrency control.

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.

Symmetric Encryption

Symmetric encryption efficiently protects stored data, application payloads, and network traffic. Its security depends on protecting the key, choosing an appropriate encryption mode, and controlling which identities can obtain keys or request decryption.

Synchronous Communication

Synchronous communication connects a request and its result within the same logical interaction, making it useful when an application needs an immediate answer. It simplifies request-response workflows but couples the caller’s latency and ability to complete dependent work to downstream services.

Temporal Correlation

Temporal correlation helps engineers reconstruct activity across application, identity, network, and cloud-service logs. During incident response, it reveals event sequences that isolated records cannot show, while requiring careful handling of clock differences, delivery delays, and incomplete evidence.

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.

Test Doubles

Test doubles let engineers test application behavior without relying on every production dependency being available, predictable, or safe to call. They make development tests faster and more repeatable, but must be complemented by tests against real integrations to detect configuration problems and differences from actual service behavior.

Throughput

Throughput measures the rate at which storage, networks, applications, and data pipelines deliver results, commonly expressed as bytes, operations, or records per second. It matters when selecting storage configurations, sizing ingestion and transformation workloads, and determining whether a system can meet processing deadlines without accumulating a backlog.

Time to Live

Time to Live (TTL) controls the lifetime of cached responses, DNS records, and other temporary data. Engineers use it to balance freshness, latency, backend load, and storage consumption, but expiration behavior depends on the system implementing it.

Timeouts

Timeouts prevent slow or unresponsive dependencies from consuming application resources indefinitely. In cloud applications, they work with deadlines, bounded retries, circuit breakers, and error handling to keep third-party integration failures from spreading across the system.

Token Validation

Cloud applications and identity systems validate tokens before trusting the identities or claims they contain. Correct validation prevents forged, expired, misdirected, or inappropriate tokens from being accepted, while separating authentication failures from authorization problems.

Trace Sampling

Distributed tracing follows a request across services, while sampling determines which requests contribute detailed trace data. A well-designed sampling policy controls telemetry volume without losing too much visibility into failures, latency, and important application workflows.

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.

Trunk-Based Development

The shared trunk remains the authoritative integration point and is kept releasable through automated testing, rapid feedback, and prompt repair of failures. This reduces divergence and large merge conflicts while enabling CI/CD pipelines to promote validated changes consistently across application environments.

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.

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.

Webhooks

A webhook lets an event producer send a request to a registered endpoint instead of requiring the consumer to repeatedly poll for changes. Engineers use webhooks to trigger builds and tests, integrate enterprise applications, and start asynchronous AI workflows, while explicitly handling authentication, retries, and duplicate deliveries.

Workflow Orchestration

An orchestrator maintains the execution state of a process and determines which task runs next, including parallel work, waits, retries, and exception paths. In cloud applications, this separates business coordination from individual functions and services, making integrations easier to operate, recover, and audit.

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.

Write-Through Caching

Write-through caching populates or refreshes cached data when that data is written, rather than waiting for a later read miss. It can improve subsequent read performance and reduce database read load, but adds work to the write path and requires explicit handling of failures and concurrent updates.

Services on the exam

The 58 AWS services the DVA-C02 exam covers.

Concepts on the exam

The 156 cloud concepts the DVA-C02 exam covers, each explained with the AWS services that implement it, in the Cloud Concepts Hub .

Other practice exams