AWS Certified Developer - Associate (DVA-C02) Exam Prep
Work through every domain, task and service of the AWS Certified Developer - Associate (DVA-C02) exam guide v2.1 at developer depth, with SDK and CLI calls, IAM policies, SAM templates, buildspec and appspec files, and original scenario questions with every distractor explained. Independent of AWS.
Read lesson 1 free →Try 10 practice questions free →
Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. 10 questions from the bank behind this course's timed mock are free to try, no account needed.

Expert · 61 levels · 4 free · Created Oct 2026 · Professionally curated by levelupwith.com
What's inside
- Level 1: Exam Briefing, AWS CLI, SDKs and CloudShellFree
[All domains – exam orientation] States that this course is independent of AWS and promises no pass, then covers the DVA-C02 format (65 questions with 50 scored and 15 unscored, 130 minutes, scaled pass mark 720 of 1,000, multiple choice and multiple response, no penalty for guessing), the four weighted domains, and the AWS CLI, AWS SDKs and AWS CloudShell used in every later level.- State the exam format, the compensatory scoring model and the four domain weightings (32%, 26%, 24%, 18%), and explain why unanswered questions should always be guessed
- Dissect a scenario question into requirement, constraint and qualifier (such as 'least operational overhead') and eliminate distractors methodically
- Run a first AWS CLI command from AWS CloudShell and explain how named profiles, Regions and output formats shape every CLI and SDK call
- Level 2: Architectural Patterns and CouplingFree
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Covers the vocabulary of Skills 1.1.1 to 1.1.4: event-driven, microservices, monolithic, choreography, orchestration and fanout patterns, stateful versus stateless, tightly versus loosely coupled components, and synchronous versus asynchronous patterns.- Recognise event-driven, microservices, monolithic, choreography, orchestration and fanout patterns from a short scenario description
- Explain why stateless components scale horizontally and where state should move to (a data store, a cache or a token) when it is removed from a server
- Decide whether a scenario calls for a synchronous request/response call or an asynchronous, loosely coupled hand-off, and name the trade-off of each
- Level 3: Calling AWS Services with APIs and SDKsFree account
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Covers Skill 1.1.9: how an SDK or AWS CLI call becomes a signed HTTPS request to a service endpoint, how credentials are resolved, and how to handle pagination, waiters and service error responses in code.- Trace an SDK call from client construction through the default credential provider chain, Region selection and request signing to the service's response
- Use paginators and waiters in an SDK, and the --query and pagination options in the AWS CLI, to read complete result sets
- Distinguish client-side 4xx errors from server-side 5xx and throttling errors in an SDK exception, and say which are worth retrying
- Level 4: Where Code Runs: EC2, Elastic Beanstalk, ECS, EKSFree account
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Explains from first principles the non-Lambda compute services a developer deploys to — Amazon EC2, AWS Elastic Beanstalk, Amazon ECS and Amazon EKS — and what each asks the developer to supply and configure.- Contrast what the developer manages on EC2, Elastic Beanstalk, ECS (including the AWS Fargate launch type) and EKS, and choose one for a given scenario
- Explain how application code on EC2 obtains temporary credentials from an instance profile through the instance metadata service, and how an ECS task gets its own through a task role
- Read an ECS task definition and an Elastic Beanstalk environment configuration and identify the image, ports, environment variables and roles they set
- Level 5: Building APIs with Amazon API Gateway
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Covers Skill 1.1.6 with Amazon API Gateway: creating, extending and maintaining APIs, including integration types, stages, request/response transformations, enforcing validation rules and overriding status codes.- Contrast REST APIs, HTTP APIs and WebSocket APIs and the Lambda proxy, Lambda non-proxy (custom), HTTP and mock integration types
- Write a mapping template that transforms a request or response and overrides the returned status code, and attach a request validator with a model to reject malformed input before the backend is called
- Use stages, stage variables and deployments to maintain several versions of an API, and explain why a change is invisible until it is deployed to a stage
- Level 6: GraphQL APIs with AWS AppSync
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Extends Skill 1.1.6 to AWS AppSync: a managed GraphQL API whose schema, resolvers and data sources let clients fetch exactly the fields they need and receive real-time updates.- Explain schema, query, mutation, subscription, resolver and data source, and how a resolver connects a field to DynamoDB, Lambda or an HTTP endpoint
- Choose between AWS AppSync and Amazon API Gateway for a scenario based on client data-shaping needs, real-time subscriptions and multiple data sources
- Read a short GraphQL schema and resolver and predict which data source is called and what the client receives
- Level 7: Queues in Code: Amazon SQS
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Covers the queue half of Skill 1.1.8, writing code to use messaging services, with Amazon SQS: sending, receiving and deleting messages, and the settings that control delivery behaviour.- Write the SendMessage, ReceiveMessage and DeleteMessage loop and explain what the visibility timeout does when a consumer is slow or crashes
- Contrast standard and FIFO queues (at-least-once versus exactly-once processing, message group ID, deduplication ID) and pick one for a scenario
- Configure long polling, delay queues, batch calls and a redrive policy to a dead-letter queue, and explain the problem each one solves
- Level 8: Publish/Subscribe and Fanout: Amazon SNS
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Covers the publish/subscribe half of Skill 1.1.8 with Amazon SNS: topics, subscriptions and protocols, and the SNS-to-SQS fanout pattern named in Skill 1.1.1.- Publish a message with message attributes to a topic by SDK or AWS CLI and list the subscription endpoint types a topic can deliver to
- Build the fanout pattern by subscribing several SQS queues to one SNS topic, including the queue access policy that allows the topic to send
- Explain when SNS (push to many subscribers) fits better than SQS (pull by one consumer group), and when raw message delivery and FIFO topics apply
- Level 9: Event-Driven Patterns with Amazon EventBridge
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Covers Skill 1.1.12: using Amazon EventBridge event buses, rules, event patterns and targets to implement event-driven, choreographed applications.- Write an event pattern that matches on source, detail-type and fields inside detail, and attach a rule with a target to an event bus
- Publish a custom event with PutEvents and contrast the default event bus, custom event buses and partner event sources
- Choose between EventBridge, SNS and SQS for a scenario based on content-based routing, the number and type of targets, and scheduling needs
- Level 10: Orchestration with AWS Step Functions
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Teaches the orchestration pattern of Skill 1.1.1 at developer depth with AWS Step Functions: state machines written in Amazon States Language that coordinate services with built-in error handling.- Read an Amazon States Language definition and identify Task, Choice, Parallel, Map, Wait, Succeed and Fail states and the data passed between them
- Add Retry and Catch blocks to a Task state so that failures are retried with backoff or routed to a fallback state instead of being handled in application code
- Contrast Standard and Express workflows and decide when a state machine is a better fit than chaining Lambda functions or choreographing with events
- Level 11: Handling Streaming Data with Amazon Kinesis
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Covers Skill 1.1.10: handling streaming data with Amazon Kinesis Data Streams (shards, partition keys, producers and consumers) and delivery to stores with Amazon Data Firehose.- Explain how a partition key maps a record to a shard, why ordering holds only within a shard, and what a hot shard looks like
- Write records with PutRecord and PutRecords and handle ProvisionedThroughputExceededException and partial batch failures correctly
- Contrast Kinesis Data Streams with SQS and with Amazon Data Firehose on replay, multiple consumers, ordering and operational effort
- Level 12: Fault-Tolerant Code: Retries, Backoff, Circuit Breakers
[Development with AWS Services – Task 1: Develop code for applications hosted on AWS] Covers Skills 1.1.5 and 1.1.13: creating fault-tolerant and resilient application code, including retry logic, circuit breakers and error handling patterns for third-party service integrations.- Implement retries with exponential backoff and jitter, configure SDK retry modes and timeouts, and explain why unbounded retries make an outage worse
- Make an operation idempotent with an idempotency key or a conditional write so that a retried request cannot apply twice
- Apply a circuit breaker and a fallback around a slow third-party API and explain how the closed, open and half-open states protect the caller
- Level 13: AWS Lambda Configuration and VPC Access
[Development with AWS Services – Task 2: Develop code for AWS Lambda] Covers Skills 1.2.1 and 1.2.2: how Lambda runs code, how to configure a function (memory, concurrency, timeout, runtime, handler, layers, extensions, environment variables), and how Lambda code reaches private resources in a VPC.- Explain the execution environment lifecycle (init, invoke, shutdown), cold starts, and why clients and connections are created outside the handler
- Set memory, timeout, runtime, handler, environment variables, layers, extensions, and reserved and provisioned concurrency by AWS CLI or template, and state what each one affects
- Attach a function to VPC subnets and security groups to reach a private database, and explain why it then needs a NAT gateway or VPC endpoints to reach the internet or AWS service APIs
- Level 14: Lambda Invocation Models and Event Sources
[Development with AWS Services – Task 2: Develop code for AWS Lambda] Covers Skills 1.2.5 and 1.2.7: integrating Lambda functions with AWS services through triggers and event source mappings, and using Lambda to process and transform data in near real time from queues and streams.- Classify an integration as synchronous invocation, asynchronous invocation or a poll-based event source mapping, and name which side holds the permission in each case
- Configure an event source mapping for SQS, Kinesis or DynamoDB Streams with batch size, batching window and starting position, and read the event payload each one delivers
- Write a handler that transforms a batch of stream records and reports partial batch failures so that only the failed records are retried
- Level 15: Lambda Errors: Destinations and Dead-Letter Queues
[Development with AWS Services – Task 2: Develop code for AWS Lambda] Covers Skill 1.2.3: handling the event lifecycle and errors in code, including retry behaviour for each invocation type, Lambda Destinations and dead-letter queues.- Predict what happens to a failed event under synchronous invocation, asynchronous invocation and a stream or queue event source mapping, including who performs the retry
- Configure on-success and on-failure Lambda Destinations and contrast them with a function dead-letter queue and with an SQS source queue's own redrive policy
- Tune maximum retry attempts, maximum event age, bisect batch on function error and on-failure destinations so that a poison record cannot block a shard
- Level 16: Testing Code with AWS SAM and Amazon Q Developer
[Development with AWS Services – Tasks 1 and 2] Covers Skills 1.1.7, 1.2.4 and 1.1.11: writing and running unit tests in development environments (for example, using AWS SAM), testing Lambda code with AWS services and tools, and using Amazon Q Developer to assist with development.- Read a minimal AWS SAM template and use sam local invoke, sam local start-api and sam local generate-event to run a function against sample events on a development machine
- Structure a handler so its business logic can be unit tested with mocked SDK clients, and use test events to exercise a deployed function
- Describe what Amazon Q Developer offers in the IDE and command line (code suggestions, chat, test generation, security scanning) and why its output must still be reviewed
- Level 17: Amazon DynamoDB Keys and Indexes
[Development with AWS Services – Task 3: Use data stores in application development] Covers Skills 1.3.1 and 1.3.4: Amazon DynamoDB from first principles — tables, items, partition and sort keys, why high-cardinality partition keys give balanced partition access, and local and global secondary indexes.- Choose a partition key and sort key for a stated access pattern and explain how a low-cardinality key creates a hot partition and throttling
- Contrast a local secondary index and a global secondary index on key schema, when each can be created, consistency options and capacity
- Read a create-table definition and identify the key schema, attribute definitions, index projections, and on-demand or provisioned capacity mode
- Level 18: DynamoDB in Code: Query vs Scan and Consistency
[Development with AWS Services – Task 3: Use data stores in application development] Covers Skills 1.3.2, 1.3.3 and 1.3.5: the differences between query and scan operations, strongly consistent and eventually consistent reads, and serializing and deserializing application objects to DynamoDB items.- Write a Query with a key condition expression, filter expression and projection expression, and explain why a Scan with a filter still reads and is charged capacity for every item
- Choose strongly consistent or eventually consistent reads for a scenario, and use condition expressions for optimistic locking and safe concurrent writes
- Marshal objects to DynamoDB attribute values with an SDK's document or mapper interface, and handle paginated results and unprocessed items from batch operations
- Level 19: Relational, Cache and Specialised Data Stores
[Development with AWS Services – Task 3: Use data stores in application development] Covers Skills 1.3.6, 1.3.8 and 1.3.9: using and maintaining Amazon RDS and Amazon Aurora from application code, using data caching services with Amazon ElastiCache, and choosing specialised stores such as Amazon OpenSearch Service and Amazon Athena by access pattern.- Connect application code to RDS or Aurora using writer and reader endpoints and connection pooling, and explain how read replica lag gives eventually consistent reads
- Implement lazy loading and write-through caching with ElastiCache, set a TTL, and name the stale-data and cache-miss trade-offs of each strategy
- Match an access pattern to a store: full-text search and log analytics to OpenSearch Service, SQL over files in S3 to Athena, key-value lookups to DynamoDB, joins and transactions to RDS or Aurora
- Level 20: Amazon S3, EBS and EFS: Storage and Data Lifecycles
[Development with AWS Services – Task 3: Use data stores in application development] Covers Skill 1.3.7, managing data lifecycles, and completes Skill 1.3.6 for storage: Amazon S3 object operations and lifecycle rules, DynamoDB Time to Live, and when application code should use Amazon EBS block storage or Amazon EFS shared file storage instead.- Use the S3 API from code: put and get objects, multipart upload, presigned URLs, versioning and event notifications
- Write an S3 Lifecycle configuration that transitions objects between storage classes and expires them, and use DynamoDB TTL to expire items without a delete job
- Choose between S3, EBS and EFS for a scenario based on object, block or shared file access and on how many compute instances or Lambda functions need the data
- Level 21: IAM Principals and Policy Anatomy
[Domain 2: Security – Task 1, Skill 2.1.6 Define permissions for IAM principals] Explains from first principles what an IAM principal is (user, role, AWS service, federated identity) and how to read and write a JSON identity-based policy with Effect, Action, Resource and Condition, using a least-privilege policy for an S3 bucket and a DynamoDB table as the worked example.- Read an IAM policy document and state exactly which API calls it allows on which resources
- Write a least-privilege identity-based policy for a developer scenario using specific actions and ARNs instead of wildcards
- Tell apart AWS managed, customer managed and inline policies and say when each is the sensible choice
- Level 22: Policy Evaluation: Deny, Resource Policies, Conditions
[Domain 2: Security – Task 1, Skill 2.1.6 Define permissions for IAM principals] Teaches how AWS decides allow or deny when several policies apply: explicit deny wins, default deny, identity-based versus resource-based policies (S3 bucket policies, SQS queue policies, Lambda resource-based policies), permissions boundaries, and condition keys and policy variables such as aws:SourceArn and ${aws:username}.- Predict the outcome of a request when identity-based policies, resource-based policies and a permissions boundary all apply
- Choose between an identity-based and a resource-based policy for same-account and cross-account access scenarios
- Use condition keys and policy variables to narrow a permission, and diagnose an AccessDenied error from the policy set
- Level 23: Programmatic Access and Signed Calls to AWS
[Domain 2: Security – Task 1, Skills 2.1.3 Configure programmatic access to AWS and 2.1.4 Make authenticated calls to AWS services] Shows how the AWS CLI and SDKs find credentials (the default credential provider chain, named profiles, environment variables, EC2 instance profiles, ECS task roles, Lambda execution roles) and how every request is signed with Signature Version 4, including why long-term access keys in code are the wrong answer.- Configure the AWS CLI and an SDK with named profiles and explain the order in which the credential provider chain is searched
- Pick the correct credential source for code on EC2, ECS, EKS, Lambda and a developer laptop without embedding access keys
- Explain what Signature Version 4 signs and recognise the errors caused by expired credentials, clock skew or a wrong Region
- Level 24: Assuming IAM Roles with AWS STS
[Domain 2: Security – Task 1, Skill 2.1.5 Assume an IAM role] Covers AWS Security Token Service at developer depth: the sts:AssumeRole call, the role trust policy versus the permissions policy, temporary credentials and session duration, cross-account access with an external ID, role chaining limits, and get-caller-identity as the first debugging step.- Write a role trust policy and call aws sts assume-role from the CLI or an SDK to obtain temporary credentials
- Set up cross-account access to a resource using a role in the target account and explain where each policy lives
- Troubleshoot a failed AssumeRole call by checking the trust policy, the caller's sts:AssumeRole permission and session limits
- Level 25: Federated Access with Identity Providers
[Domain 2: Security – Task 1, Skill 2.1.1 Use an identity provider to implement federated access] Explains federation from first principles: trusting an external identity provider through IAM using SAML 2.0 or OpenID Connect, the STS calls AssumeRoleWithSAML and AssumeRoleWithWebIdentity, and when to federate through IAM directly versus through Amazon Cognito.- Describe the token exchange that turns an external identity into temporary AWS credentials
- Match a scenario to AssumeRoleWithSAML, AssumeRoleWithWebIdentity or Amazon Cognito
- Write the trust policy conditions that restrict a federated role to a specific identity provider and audience
- Level 26: Amazon Cognito User Pools: Sign-In and Tokens
[Domain 2: Security – Task 1, Skills 2.1.1 Use an identity provider to implement federated access and 2.1.2 Secure applications by using bearer tokens] Teaches Amazon Cognito user pools as a user directory and OIDC identity provider: app clients, sign-up and sign-in flows, managed login, social and SAML sign-in through the pool, MFA, Lambda triggers, and the ID, access and refresh tokens the pool issues.- Configure a user pool and app client and describe what the ID token, access token and refresh token are each for
- Choose the right Lambda trigger (for example pre sign-up, post confirmation, pre token generation) for a customisation scenario
- Explain how a user pool federates sign-in from social and SAML identity providers while still issuing its own tokens
- Level 27: Amazon Cognito Identity Pools: AWS Credentials for Users
[Domain 2: Security – Task 1, Skill 2.1.1 Use an identity provider to implement federated access] Contrasts identity pools with user pools: an identity pool exchanges a token from a user pool or other provider for temporary AWS credentials through STS, with authenticated and unauthenticated (guest) roles and role mapping, so a web or mobile app can call services such as S3 or DynamoDB directly.- State the difference between a user pool (who you are, tokens) and an identity pool (temporary AWS credentials) and pick the right one in a scenario
- Trace the flow from user pool sign-in to identity pool credentials to a direct S3 or DynamoDB call
- Configure authenticated and unauthenticated roles and role mapping so guests and signed-in users get different permissions
- Level 28: Bearer Tokens and API Gateway Authorizers
[Domain 2: Security – Task 1, Skill 2.1.2 Secure applications by using bearer tokens] Shows how an API verifies a JSON Web Token (signature, expiry, audience, scopes) and compares the ways to protect an Amazon API Gateway API: IAM authorization with Signature Version 4, Cognito user pool authorizers, Lambda authorizers, JWT authorizers on HTTP APIs, resource policies, API keys with usage plans, and AWS WAF in front for request filtering.- Explain what must be validated in a JWT bearer token before trusting its claims
- Choose between IAM authorization, a Cognito user pool authorizer, a Lambda authorizer and a JWT authorizer for a given scenario
- Explain why API keys and AWS WAF rules are not authentication, and tell 401 from 403 responses when an authorizer rejects a request
- Level 29: Fine-Grained Authorization and Service-to-Service Auth
[Domain 2: Security – Task 1, Skills 2.1.7 Implement application-level authorization for fine-grained access control and 2.1.8 Handle cross-service authentication in microservice architectures] Covers authorizing inside the application: Cognito groups, custom claims and OAuth scopes, the Lambda authorizer's policy and context output, AWS AppSync authorization modes, and DynamoDB fine-grained access with dynamodb:LeadingKeys; then how microservices authenticate to each other with IAM roles and Signature Version 4, resource-based policies, and the OAuth client credentials grant.- Enforce per-user or per-group access using token claims, scopes and IAM condition keys such as dynamodb:LeadingKeys
- Select the appropriate AWS AppSync authorization mode or API Gateway authorizer output for a fine-grained access requirement
- Choose how one microservice authenticates to another: IAM role with SigV4, resource-based policy, or machine-to-machine tokens
- Level 30: Encryption at Rest, in Transit, Client-Side, Server-Side
[Domain 2: Security – Task 2, Skills 2.2.1 Define encryption at rest and in transit and 2.2.3 Describe differences between client-side encryption and server-side encryption] Defines the four terms with concrete cases: TLS to AWS endpoints and enforcing it with aws:SecureTransport; the Amazon S3 server-side options SSE-S3, SSE-KMS, DSSE-KMS and SSE-C; encryption settings for EBS, EFS, RDS, Aurora, DynamoDB and SQS; and client-side encryption where data is encrypted before it leaves the application.- Define encryption at rest and in transit and name the mechanism that provides each for S3, EBS, RDS and DynamoDB
- Choose between SSE-S3, SSE-KMS, DSSE-KMS, SSE-C and client-side encryption from the requirements in a scenario
- Write a bucket policy statement that denies requests not using TLS or not using the required encryption header
- Level 31: AWS KMS Keys and Envelope Encryption
[Domain 2: Security – Task 2, Skill 2.2.4 Use encryption keys to encrypt or decrypt data] Teaches AWS Key Management Service at API depth: AWS owned, AWS managed and customer managed keys; Encrypt, Decrypt and ReEncrypt and their 4 KB limit; GenerateDataKey and envelope encryption for larger data; encryption context; the AWS Encryption SDK; and KMS request quotas with S3 Bucket Keys as the fix for throttling.- Call kms encrypt, decrypt and generate-data-key from the CLI or an SDK and say what each returns
- Implement envelope encryption step by step and explain why the plaintext data key must be discarded after use
- Diagnose KMS errors such as AccessDeniedException, an encryption context mismatch and ThrottlingException
- Level 32: KMS Key Policies, Cross-Account Use and Rotation
[Domain 2: Security – Task 2, Skills 2.2.6 Use encryption across account boundaries and 2.2.7 Enable and disable key rotation] Covers who may use a KMS key: the key policy as the root of access, IAM policies and grants, the kms:ViaService condition, sharing a customer managed key with another account (key policy plus the caller's IAM policy), and automatic versus on-demand versus manual key rotation and what each does to existing ciphertext.- Write a key policy and matching IAM policy that let a principal in another account decrypt with a customer managed key
- Explain why data encrypted with an AWS managed key cannot be shared across accounts and what to use instead
- Enable, disable and reason about key rotation, including which key types support automatic rotation and when an alias-based manual rotation is needed
- Level 33: Certificates, AWS Private CA and SSH Keys
[Domain 2: Security – Task 2, Skills 2.2.2 Describe certificate management (for example, AWS Private CA) and 2.2.5 Generate certificates and SSH keys for development purposes] Explains what a TLS certificate proves, public certificates from AWS Certificate Manager attached to Elastic Load Balancing, CloudFront and API Gateway, private certificates from AWS Private CA for internal services, and generating self-signed certificates and EC2 key pairs for development work.- Describe how ACM issues, validates and renews public certificates and which Region a CloudFront certificate must be in
- Decide when a scenario calls for AWS Private CA rather than a public ACM certificate or a self-signed certificate
- Generate an EC2 key pair with the CLI and a self-signed certificate for a development environment, and explain why neither belongs in production
- Level 34: Secrets Manager, Parameter Store and Encrypted Env Vars
[Domain 2: Security – Task 3, Skills 2.3.2 Encrypt environment variables that contain sensitive data and 2.3.3 Use secret management services to secure sensitive data] Compares AWS Secrets Manager (automatic rotation, cross-account resource policies, GetSecretValue) with AWS Systems Manager Parameter Store (String, StringList, SecureString, hierarchies, GetParametersByPath), covers how Lambda environment variables are encrypted with KMS including encryption helpers, and shows fetching and caching secrets at runtime instead of hard-coding them.- Choose between Secrets Manager and Parameter Store SecureString from rotation, sharing and size requirements
- Retrieve a secret or parameter from code or the CLI with the right IAM and KMS permissions, and cache it sensibly
- Explain how Lambda environment variables are encrypted at rest and when to add a customer managed key or fetch from a secret store instead
- Level 35: Data Classification, Masking and Multi-Tenant Access
[Domain 2: Security – Task 3, Skills 2.3.1 Describe data classification, 2.3.4 Sanitize sensitive data, 2.3.5 Implement application-level data masking and sanitization and 2.3.6 Implement data access patterns for multi-tenant applications] Defines personally identifiable information (PII) and protected health information (PHI), then teaches keeping them out of logs, traces and error messages by sanitising inputs and masking outputs (including CloudWatch Logs data protection policies), and isolating tenants with tenant-scoped partition keys, IAM policy conditions and per-tenant credentials or keys.- Classify fields in a sample payload as PII, PHI or non-sensitive and decide how each must be handled
- Mask or redact sensitive values in application code and logs, and say what a CloudWatch Logs data protection policy adds
- Pick a multi-tenant data access pattern (shared table with tenant key and scoped credentials versus separate resources) for a scenario
- Identify the security risks of integrating AI services into an application and mitigate them with data privacy controls, access management, controls on model inputs and outputs, secured AI agent inter
- Level 36: Lambda Deployment Packages: Zip, Layers, Images
[Domain 3: Deployment – Task 1, Skills 3.1.1 Manage the dependencies of the code module within the package and 3.1.2 Organize files and a directory structure for application deployment; Task 4, Skill 3.4.1 Describe Lambda deployment packaging options] Covers the three ways to ship Lambda code: .zip archives (direct upload versus from S3, size limits, handler path and folder layout), Lambda layers for shared dependencies, and container images, with the trade-offs of each.- Lay out a function's files and dependencies so the handler resolves, and build a valid .zip deployment package
- Decide between a .zip archive, a layer and a container image from size, dependency and tooling requirements
- Publish a layer and update function code with the CLI, and recognise the errors caused by oversized or badly structured packages
- Level 37: Container Images, Amazon ECR and Resource Requirements
[Domain 3: Deployment – Task 1, Skills 3.1.1 Manage the dependencies of the code module (container images) and 3.1.4 Apply application requirements for resources (for example, memory, cores)] Teaches preparing a container artifact: building and tagging an image, authenticating Docker to Amazon ECR and pushing, image tag immutability, image scanning and lifecycle policies, then declaring CPU and memory in an ECS task definition and memory and ephemeral storage on a Lambda function.- Authenticate to Amazon ECR with get-login-password, then tag and push an image to a repository
- Use tag immutability, image scanning and lifecycle policies to keep a repository safe and tidy
- Set task-level and container-level CPU and memory in an ECS task definition and explain what happens when a container exceeds its limit
- Level 38: Dependencies and Repositories with AWS CodeArtifact
[Domain 3: Deployment – Task 1, Skills 3.1.1 Manage the dependencies of the code module (environment variables, configuration files) and 3.1.3 Use code repositories in deployment environments] Explains how a build gets its inputs: AWS CodeArtifact domains, repositories and upstream repositories for npm, pip and Maven packages, authorization tokens for package managers, source code repositories as the trigger and input for deployments, and keeping environment variables and configuration files out of the artifact so one build runs everywhere.- Configure a package manager to pull from an AWS CodeArtifact repository using a login or authorization token
- Explain domains, repositories, upstream repositories and external connections, and why approved packages are pinned there
- Separate build artifact from environment configuration so the same package deploys unchanged to development, test and production
- Level 39: Environment-Specific Configuration with AWS AppConfig
[Domain 3: Deployment – Task 1, Skill 3.1.5 Prepare application configurations for specific environments (for example, by using AWS AppConfig)] Teaches AWS AppConfig from first principles: applications, environments and configuration profiles, feature flags and freeform configuration, validators, deployment strategies with bake time and alarm-based rollback, and retrieving configuration from code through the AppConfig Agent or Lambda extension.- Create an AppConfig application, environment and configuration profile and deploy a feature flag change without redeploying code
- Choose a deployment strategy and validator so a bad configuration is caught or rolled back automatically
- Decide between AppConfig, Parameter Store and Lambda environment variables for a configuration scenario
- Level 40: AWS CloudFormation Template Fundamentals
[Domain 3: Deployment – Task 3, Skill 3.3.4 Implement and deploy infrastructure as code (IaC) templates (for example, AWS CloudFormation templates)] Introduces infrastructure as code with AWS CloudFormation: templates and stacks, the Parameters, Mappings, Conditions, Resources and Outputs sections, intrinsic functions such as Ref, Fn::GetAtt and Fn::Sub, pseudo parameters, and creating a stack from the CLI and reading its events when it fails.- Read and write a small CloudFormation template that uses Parameters, Resources and Outputs with Ref, Fn::GetAtt and Fn::Sub
- Deploy a template as a stack with the AWS CLI and pass different parameter values for different environments
- Find the cause of a failed stack creation from stack events and explain what the automatic rollback did
- Level 41: Testing Lambda Code with Test Events and SAM
[Domain 3: Deployment – Task 2: Test applications in development environments; Task 3: Automate deployment testing] You learn to test deployed and local code using JSON test events for Lambda, API Gateway and AWS SAM resources, including the event shapes that event-driven applications receive from SQS, SNS, EventBridge and S3.- Generate and edit JSON test event payloads with `sam local generate-event` and Lambda console test events, matching the event shape each source sends
- Run a function locally with `sam local invoke` and `sam local start-api`, and against the deployed stack with `sam remote invoke` or `aws lambda invoke`
- Test an event-driven flow end to end by publishing a test message or event and checking the logs and the downstream result
- Level 42: Integration Tests, Mock APIs and Development Endpoints
[Domain 3: Deployment – Task 2: Test applications in development environments] You learn to write integration tests against real development endpoints, and to replace external dependencies with mock APIs such as API Gateway mock integrations, so tests stay repeatable.- Configure an API Gateway mock integration with mapping templates to stand in for a dependency that is unavailable or not yet built
- Tell unit tests, integration tests and mocked tests apart, and choose the right one for a scenario
- Point a test suite at a development stage's invoke URL and check status codes, headers and response bodies
- Level 43: API Gateway Stages, Stage Variables and Custom Domains
[Domain 3: Deployment – Task 3: Automate deployment testing; Task 4: Deploy code by using CI/CD services] You learn how API Gateway separates development, test and production using deployments, stages, stage variables and custom domain names, and how stage variables drive dynamic deployments into Lambda.- Create a deployment and promote it across dev, test and prod stages with the AWS CLI, knowing that changes are not live until they are deployed to a stage
- Use a stage variable to route each stage to a different Lambda alias, and grant the invoke permission that alias needs
- Map a custom domain name and base path to stages, and name the certificate and Route 53 record this requires
- Level 44: Approved Versions: Aliases, Image Tags and Branches
[Domain 3: Deployment – Task 3: Automate deployment testing; Task 4: labels and branches for release management] You learn to build integration-test environments that pin approved versions using Lambda versions and aliases, container image tags and digests in ECR, AWS Amplify branches and AWS Copilot environments, and to use Amazon Q Developer to generate automated tests.- Publish an immutable Lambda version and move an alias to it, and explain why `$LATEST` is the wrong target for a test or production environment
- Choose between mutable tags, immutable tags and image digests when pinning a container image for an ECS or EKS test environment
- Use Git branches and tags to mark releases, connect a branch to an Amplify environment, and ask Amazon Q Developer to generate unit tests that you then review
- Level 45: Updating IaC Stacks Across Environments
[Domain 3: Deployment – Task 2: deploy application stack updates to existing environments; Task 3 and Task 4: implement, deploy and update IaC templates] You learn to update existing AWS SAM and CloudFormation stacks safely and to deploy one template to several staging environments using parameters, change sets and `samconfig.toml`.- Deploy one SAM template to dev and staging with `sam deploy --config-env` and parameter overrides, without copying the template
- Create and review a CloudFormation change set, and spot the updates that replace a resource rather than modify it in place
- Explain what happens when a stack update fails (automatic rollback and `UPDATE_ROLLBACK_FAILED`), and how stack policies and `DeletionPolicy` protect data
- Level 46: CodeBuild and the buildspec File
[Domain 3: Deployment – Task 4: Deploy code by using AWS CI/CD services] You learn how AWS CodeBuild turns a commit into tested artifacts, by reading and writing a `buildspec.yml` with its phases, environment variables, artifacts, reports and cache.- Write a buildspec with install, pre_build, build and post_build phases that runs tests, builds a container image and pushes it to Amazon ECR
- Inject configuration and secrets through the `env` section from Systems Manager Parameter Store and Secrets Manager, not as plaintext
- Diagnose common build failures: missing service role permissions, wrong artifact paths, no privileged mode for Docker builds, and no VPC access to private resources
- Level 47: CodeDeploy on EC2: appspec, Hooks and Rolling Deploys
[Domain 3: Deployment – Task 4: deployment strategies, rollbacks] You learn how AWS CodeDeploy deploys to the EC2/on-premises compute platform with an `appspec.yml`, lifecycle event hooks, in-place and blue/green deployment types, and deployment configurations that control rolling behaviour.- Write an `appspec.yml` with a `files` section and hooks such as BeforeInstall, AfterInstall, ApplicationStart and ValidateService, in the correct order
- Choose between the AllAtOnce, HalfAtATime and OneAtATime deployment configurations, and between in-place and blue/green deployments behind a load balancer
- Configure automatic rollback on a failed deployment or a CloudWatch alarm, and explain that a rollback is a new deployment of the last known good revision
- Level 48: Canary, Linear and Blue/Green for Lambda and ECS
[Domain 3: Deployment – Task 4: configure deployment strategies (blue/green, canary, rolling) and perform rollbacks] You learn how CodeDeploy shifts traffic for Lambda aliases and Amazon ECS services using canary, linear and all-at-once configurations, and how AWS SAM sets this up with `AutoPublishAlias` and `DeploymentPreference`.- Add `AutoPublishAlias` and a `DeploymentPreference` with pre-traffic and post-traffic hook functions and alarms to a SAM template
- Contrast canary, linear, all-at-once, rolling and blue/green by blast radius, speed and rollback behaviour, and pick one from a scenario
- Read a Lambda or ECS appspec and explain how the validation hooks and the load balancer's test listener gate the traffic shift
- Level 49: CodePipeline, Beanstalk Policies and Amplify Releases
[Domain 3: Deployment – Task 4: commit code to invoke build, test and deployment actions; orchestrated workflows; manage application environments] You learn to orchestrate source, build, test, approval and deploy stages in AWS CodePipeline, and to manage environments with Elastic Beanstalk deployment policies and AWS Amplify branch deployments.- Design a pipeline whose source stage is triggered by a repository commit and that passes artifacts through CodeBuild, a manual approval action and CodeDeploy or CloudFormation deploy actions into separate environments
- Choose between the Elastic Beanstalk policies (all at once, rolling, rolling with additional batch, immutable, traffic splitting) and a blue/green CNAME swap for a given downtime and capacity requirement
- Fix a stalled or failed pipeline by checking the action's role permissions, artifact names and failed-stage details, then retry or roll back the stage
- Describe how AWS AI tools can support a CI/CD workflow through automated deployment approvals, environment provisioning and post-deployment validation, and say where human review is still required.
- Level 50: Logging, Monitoring, Observability and Structured Logs
[Domain 4: Troubleshooting and Optimization – Task 2: Instrument code for observability] You learn the differences between logging, monitoring and observability, and how to implement a logging strategy with structured JSON logs in CloudWatch Logs that record application behaviour, state and user actions without leaking sensitive data.- Explain what logs, metrics and traces each answer, and which CloudWatch or X-Ray feature provides each
- Emit structured JSON log lines with correlation IDs, request IDs and log levels from a Lambda function or container, and set log group retention
- Name the permissions and agents needed for logs to arrive: the Lambda execution role, the CloudWatch agent on EC2, and the `awslogs` driver on ECS
- Level 51: Querying Logs with CloudWatch Logs Insights
[Domain 4: Troubleshooting and Optimization – Task 1: query logs to find relevant data; Task 3: use application logs to identify performance bottlenecks] You learn to find the relevant data quickly using CloudWatch Logs Insights queries, filter patterns and metric filters, and to read Lambda REPORT lines for duration, memory and cold-start evidence.- Write Logs Insights queries using `fields`, `filter`, `parse`, `stats` and `sort` to isolate errors and slow requests across log groups
- Create a metric filter that turns a log pattern into a CloudWatch metric, and say when a subscription filter is the better tool
- Use the duration, max memory used and init duration fields in the logs to locate a performance bottleneck
- Level 52: Custom Metrics and Embedded Metric Format
[Domain 4: Troubleshooting and Optimization – Task 1: implement custom metrics (CloudWatch embedded metric format); Task 2: implement code that emits custom metrics] You learn to publish application metrics from code using `PutMetricData` and the CloudWatch embedded metric format (EMF), and when each one fits.- Write an EMF JSON log line with namespace, dimensions and metric definitions, and explain how CloudWatch extracts metrics from it asynchronously
- Call `PutMetricData` from the CLI or an SDK, and explain namespaces, dimensions, standard versus high resolution and the API throttling risk
- Choose dimensions deliberately so that high-cardinality values such as user IDs stay in log fields and do not become metric dimensions
- Level 53: Alarms, Dashboards and Notification Alerts
[Domain 4: Troubleshooting and Optimization – Task 1: review application health by using dashboards and insights; Task 2: implement notification alerts for specific actions] You learn to turn metrics into action with CloudWatch alarms, composite alarms and dashboards, and to send notifications about quota limits, errors and deployment completions through Amazon SNS and EventBridge rules.- Configure an alarm's period, evaluation periods, datapoints to alarm and missing-data treatment, and wire it to an SNS topic
- Create an EventBridge rule that notifies a team when a CodePipeline or CodeDeploy state change occurs
- Read a dashboard of Lambda, API Gateway, SQS and DynamoDB metrics (errors, throttles, iterator age, queue age) to judge application health
- Level 54: Tracing with AWS X-Ray: Segments and Annotations
[Domain 4: Troubleshooting and Optimization – Task 2: implement tracing by using AWS services and tools; add annotations for tracing services] You learn how AWS X-Ray follows a request across services using segments, subsegments, sampling and the trace map, and how to instrument code with annotations and metadata, including the OpenTelemetry-based route AWS now recommends.- Enable active tracing on Lambda and API Gateway, and instrument SDK and HTTP calls so that downstream services appear in the trace
- Add annotations (indexed, filterable) and metadata (not indexed) to a subsegment, and write a filter expression that finds traces by annotation
- Troubleshoot missing traces by checking IAM permissions, the daemon or collector on EC2, ECS and Elastic Beanstalk, the sampling rules and trace header propagation
- Level 55: Root Cause Analysis: Errors, Throttles and CloudTrail
[Domain 4: Troubleshooting and Optimization – Task 1: debug code to identify defects; interpret application metrics, logs and traces; debug service integration issues] You learn a repeatable method for root cause analysis using HTTP and SDK error codes, service metrics, traces and AWS CloudTrail to separate code defects from permission, throttling and integration faults.- Interpret 4xx versus 5xx responses and specific errors such as `AccessDenied`, `ThrottlingException`, `ProvisionedThroughputExceededException`, and API Gateway 502 and 504, and say which ones should be retried
- Use CloudTrail event history to find who made an API call and why it was denied, and tell it apart from CloudWatch application logs
- Debug integration faults such as a Lambda timeout longer than the SQS visibility timeout, malformed proxy responses, missing resource-based permissions, and retries without exponential backoff and jitter
- Use an AWS AI tool to analyse an application error and generate troubleshooting suggestions, then verify those suggestions against the logs, metrics and traces.
- Level 56: Troubleshooting Deployment Failures from Service Logs
[Domain 4: Troubleshooting and Optimization – Task 1: troubleshoot deployment failures by using service output logs] You learn where each deployment service reports failure (CloudFormation stack events, CodeBuild build logs, CodeDeploy agent and lifecycle event logs, Elastic Beanstalk events, ECS service events and stopped-task reasons) and how to read them to find the cause.- Trace a `ROLLBACK_COMPLETE` or `UPDATE_ROLLBACK_COMPLETE` stack to the first failed resource event and its status reason
- Find the failing CodeDeploy lifecycle hook and its script output on the instance, and identify agent, role or health-check causes
- Diagnose an ECS deployment that never stabilises using stopped-task reasons, image pull errors and failing target health checks
- Level 57: Health Checks, Readiness Probes and Network Behaviour
[Domain 4: Troubleshooting and Optimization – Task 2: configure application health checks and readiness probes] You learn how Elastic Load Balancing target group health checks, Route 53 health checks, ECS container health checks and Amazon EKS liveness and readiness probes decide where traffic goes, and how VPC security groups, network ACLs and subnets cause false failures.- Configure a target group health check path, thresholds and deregistration delay, and expose a lightweight health endpoint in the application
- Distinguish a liveness probe from a readiness probe on EKS and an ECS container health check from a load balancer health check
- Tell a network cause from an application cause when targets are unhealthy or connections time out, by checking security groups, network ACLs and routes before the code
- Level 58: Concurrency, Memory and Profiling for Performance
[Domain 4: Troubleshooting and Optimization – Task 3: define concurrency; profile application performance; determine minimum memory and compute power; optimize application resource usage] You learn how Lambda concurrency really works (account limits, reserved and provisioned concurrency) and how to right-size memory and compute by profiling, not guessing.- Estimate the concurrency needed from request rate and duration, and choose reserved concurrency to cap a function or protect a downstream system, or provisioned concurrency to remove cold starts
- Explain that Lambda memory also sets the CPU allocation, and find the smallest setting that meets a latency target by measuring several configurations
- Cut execution time by initialising SDK clients and connections outside the handler, trimming the package size and reusing connections through Amazon RDS Proxy
- Use AWS AI tools to detect performance bottlenecks and to identify resource usage and code efficiency improvements, and confirm each recommendation by measurement before applying it.
- Level 59: Caching Strategies and Subscription Filter Policies
[Domain 4: Troubleshooting and Optimization – Task 3: cache content based on request headers; implement application-level caching; use subscription filter policies to optimize messaging; analyze application performance issues] You learn to remove unnecessary work with CloudFront cache policies keyed on headers, API Gateway stage caching, ElastiCache lazy-loading and write-through patterns, and Amazon SNS subscription filter policies.- Choose which headers, query strings and cookies go into a CloudFront cache key, explain the effect on hit ratio, and invalidate or version objects correctly
- Implement lazy loading and write-through caching with TTLs in ElastiCache, and describe the stale-data and cache-miss trade-offs of each
- Write an SNS subscription filter policy so that subscribers receive only the messages they need, and identify the bottleneck in a slow-application scenario
- Level 60: Infrastructure as Code with the AWS CDK
[Domain 3: Deployment] Teaches the AWS Cloud Development Kit (AWS CDK), the in-scope service no earlier level names: infrastructure defined in a programming language, synthesised to AWS CloudFormation, and how it sits beside AWS SAM and hand-written templates.- Explain what the AWS Cloud Development Kit (AWS CDK) is: apps, stacks and constructs at their three levels, written in a general-purpose language and synthesised to an AWS CloudFormation template.
- Use the CDK CLI workflow in order: init, bootstrap, synth, diff, deploy and destroy, and say what bootstrapping creates in the account.
- Show a short CDK example that defines a Lambda function with a DynamoDB table or an API Gateway endpoint, and how permissions are granted between them.
- Contrast AWS CDK with AWS SAM and hand-written CloudFormation templates, and say which an exam scenario points to.
- Explain how a CDK change reaches an existing environment and what happens when a stack update fails.
- Level 61: Timed Mock Exam: 65 Questions in 130 Minutes Timed mock
[All four domains] The timed mock exam of 65 original multiple-choice and multiple-response scenario questions tests Development with AWS Services, Security, Deployment, and Troubleshooting and Optimization in proportion to their 32/26/24/18 weightings, with a 72% pass mark and every distractor explained.
Free 10 questions from the bank behind this course's timed mock are free to try, no account needed. Read all 10 with their answers →
Access
Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. 10 questions from the bank behind this course's timed mock are free to try, no account needed. Every level, the podcast edition and the AI tutor come with All Access at £4.99/month or any Creator plan — see pricing.
More like this
- Ultimate AWS SAA-C03 Mastery Path
Master AWS Solutions Architecture across security, resilience, performance, and cost domains to confidently pass the SAA-C03 exam.
Exam prep · SAA-C03 · Cloud & Compute · Expert · 45 levels · 4 free · Professionally curated by levelupwith.com
- AWS Certified Data Engineer - Associate (DEA-C01) Exam Prep
Build every skill in the current DEA-C01 exam guide from first principles, service by service, with short SQL and configuration examples and original scenario…
Exam prep · DEA-C01 · Data & Analytics · Expert · 60 levels · 4 free · Professionally curated by levelupwith.com
- AWS Certified Cloud Practitioner (CLF-C02) Exam Prep
Recognise every in-scope AWS service, reason through shared responsibility, Well-Architected, pricing and support scenarios, and answer multiple-choice and…
Exam prep · CLF-C02 · Cloud & Compute · Expert · 42 levels · 4 free · Professionally curated by levelupwith.com
- AWS Certified AI Practitioner (AIF-C01) Exam Prep
Work through all five AIF-C01 domains and every task statement so you can pick the right AI, ML or generative AI approach and the right AWS service for a…
Exam prep · AIF-C01 · AI & Agents · Capable · 18 levels · 4 free · Professionally curated by levelupwith.com
- Cloud Pro Crash Course: AWS Services Compared with Azure and Google Cloud
Quickly review the current AWS service list one category at a time.
Course · AWS · Cloud Pro: Choose and Use · Capable · 18 levels · 4 free · Professionally curated by levelupwith.com
- Cloud Pro: AWS Hybrid and Edge: Choose, Compare and Launch
Turn a site's requirements into a defensible choice between Outposts, Local Zones, Wavelength, EKS/ECS Anywhere, EKS Hybrid Nodes, Systems Manager…
Course · AWS · Cloud Pro: Choose and Use · Expert · 26 levels · 4 free · Professionally curated by levelupwith.com