AWS Certified Developer - Associate
Practice Exam Questions & Study Guide
Development with AWS ServicesFree
Covers developing, testing, and maintaining applications hosted on AWS, including Lambda functions and data store integration. (32% of scored content)
1.1: Develop code for applications hosted on AWS
Covers architectural patterns, application resilience, API creation, messaging, AWS SDK usage, and event-driven development for AWS-hosted applications.
- Describe architectural patterns (for example, event-driven, microservices, monolithic, choreography, orchestration, fanout)
- Describe differences between stateful and stateless concepts
- Describe differences between tightly coupled and loosely coupled components
- Describe differences between synchronous and asynchronous patterns
- Create fault-tolerant and resilient applications in a programming language (for example, Java, C#, Python, JavaScript, TypeScript, Go)
- Create, extend, and maintain APIs (for example, response/request transformations, enforcing validation rules, overriding status codes)
- Write and run unit tests in development environments (for example, using AWS SAM)
- Write code to use messaging services
- Write code that interacts with AWS services by using APIs and AWS SDKs
- Handle streaming data using AWS services
- Use Amazon Q Developer to assist with development
- Use Amazon EventBridge to implement event-driven patterns
- Implement resilient application code for third-party service integrations (for example, retry logic, circuit breakers, error handling patterns)
1.2: Develop code for AWS Lambda
Covers configuring, integrating, testing, tuning, and using Lambda functions for data processing and VPC resource access.
- Describe the access of private resources in VPCs from Lambda code
- Configure Lambda functions by defining environment variables and parameters (for example, memory, concurrency, timeout, runtime, handler, layers, extensions, triggers, destinations)
- Handle the event lifecycle and errors by using code (for example, Lambda Destinations, dead-letter queues)
- Write and run test code by using AWS services and tools
- Integrate Lambda functions with AWS services
- Tune Lambda functions for optimal performance
- Use Lambda functions to process and transform data in near real time
1.3: Use data stores in application development
Covers DynamoDB keys and indexing, database consistency models, data serialization, caching, lifecycle management, and specialized data stores.
- Describe high-cardinality partition keys for balanced partition access
- Describe database consistency models (for example, strongly consistent, eventually consistent)
- Describe differences between query and scan operations
- Define Amazon DynamoDB keys and indexing
- Serialize and deserialize data to provide persistence to a data store
- Use, manage, and maintain data stores
- Manage data lifecycles
- Use data caching services
- Use specialized data stores based on access patterns (for example, Amazon OpenSearch Service)
Security
Covers implementing authentication and authorization, encryption, and sensitive data management for AWS applications. (26% of scored content)
2.1: Implement authentication and-or authorization for applications and AWS services
Covers federated access, bearer tokens, IAM roles and permissions, programmatic access, and cross-service authentication in microservices.
- Use an identity provider to implement federated access (for example, Amazon Cognito, IAM)
- Secure applications by using bearer tokens
- Configure programmatic access to AWS
- Make authenticated calls to AWS services
- Assume an IAM role
- Define permissions for IAM principals
- Implement application-level authorization for fine-grained access control
- Handle cross-service authentication in microservice architectures
2.2: Implement encryption by using AWS services
Covers encryption at rest and in transit, certificate management, client-side vs. server-side encryption, key management, and cross-account encryption.
- Define encryption at rest and in transit
- Describe certificate management (for example, AWS Private CA)
- Describe differences between client-side encryption and server-side encryption
- Use encryption keys to encrypt or decrypt data
- Generate certificates and SSH keys for development purposes
- Use encryption across account boundaries
- Enable and disable key rotation
2.3: Manage sensitive data in application code
Covers data classification, encrypting environment variables, secret management, data sanitization, masking, and multi-tenant data access patterns.
- Describe data classification (for example, personally identifiable information [PII], protected health information [PHI])
- Encrypt environment variables that contain sensitive data
- Use secret management services to secure sensitive data
- Sanitize sensitive data
- Implement application-level data masking and sanitization
- Implement data access patterns for multi-tenant applications
Deployment
Covers preparing artifacts, testing in development environments, automating deployment testing, and deploying code using AWS CI/CD services. (24% of scored content)
3.1: Prepare application artifacts to be deployed to AWS
Covers managing dependencies, organizing directory structures, using code repositories, and configuring application resources and environments for deployment.
- Manage the dependencies of the code module (for example, environment variables, configuration files, container images) within the package
- Organize files and a directory structure for application deployment
- Use code repositories in deployment environments
- Apply application requirements for resources (for example, memory, cores)
- Prepare application configurations for specific environments (for example, by using AWS AppConfig)
3.2: Test applications in development environments
Covers testing deployed code, writing integration tests, using development endpoints, deploying stack updates to staging, and testing event-driven applications.
- Test deployed code by using AWS services and tools
- Write integration tests and mock APIs for external dependencies
- Test applications by using development endpoints (for example, configuring stages in Amazon API Gateway)
- Deploy application stack updates to existing environments (for example, deploying an AWS SAM template to a different staging environment)
- Test event-driven applications
3.3: Automate deployment testing
Covers creating test events, deploying API resources, managing environments with approved versions, implementing IaC templates, and using Amazon Q Developer to generate automated tests.
- Create application test events (for example, JSON payloads for testing AWS Lambda, API Gateway, AWS SAM resources)
- Deploy API resources to various environments
- Create application environments that use approved versions for integration testing (for example, Lambda aliases, container image tags, AWS Amplify branches, AWS Copilot environments)
- Implement and deploy infrastructure as code (IaC) templates (for example, AWS SAM templates, AWS CloudFormation templates)
- Manage environments in individual AWS services (for example, differentiating between development, test, and production in API Gateway)
- Use Amazon Q Developer to generate automated tests
3.4: Deploy code by using AWS Continuous Integration and Continuous Delivery (CI-CD) services
Covers Lambda packaging, API Gateway stages, IaC template updates, deployment strategies, rollbacks, version management, and configuring deployment strategies for application releases.
- Describe Lambda deployment packaging options
- Describe API Gateway stages and custom domains
- Update existing IaC templates (for example, AWS SAM templates, CloudFormation templates)
- Manage application environments by using AWS services
- Deploy an application version by using deployment strategies
- Commit code to a repository to invoke build, test, and deployment actions
- Use orchestrated workflows to deploy code to different environments
- Perform application rollbacks by using existing deployment strategies
- Use labels and branches for version and release management
- Use existing runtime configurations to create dynamic deployments (for example, using staging variables from API Gateway in Lambda functions)
- Configure deployment strategies (for example, blue/green, canary, rolling) for application releases
Troubleshooting and Optimization
Covers root cause analysis, instrumenting code for observability, and optimizing applications using AWS services and features. (18% of scored content)
4.1: Assist in a root cause analysis
Covers debugging code, interpreting metrics/logs/traces, querying logs, implementing custom metrics, reviewing application health, and troubleshooting deployment and integration failures.
- Debug code to identify defects
- Interpret application metrics, logs, and traces
- Query logs to find relevant data
- Implement custom metrics (for example, Amazon CloudWatch embedded metric format [EMF])
- Review application health by using dashboards and insights
- Troubleshoot deployment failures by using service output logs
- Debug service integration issues in applications
4.2: Instrument code for observability
Covers logging strategies, custom metrics, distributed tracing, notification alerts, structured logging, and application health checks for observability.
- Describe differences between logging, monitoring, and observability
- Implement an effective logging strategy to record application behavior and state
- Implement code that emits custom metrics
- Add annotations for tracing services
- Implement notification alerts for specific actions (for example, notifications about quota limits or deployment completions)
- Implement tracing by using AWS services and tools
- Implement structured logging for application events and user actions
- Configure application health checks and readiness probes
4.3: Optimize applications by using AWS services and features
Covers concurrency, performance profiling, resource sizing, messaging optimization, caching strategies, and identifying performance bottlenecks.
- Define concurrency
- Profile application performance
- Determine minimum memory and compute power for an application
- Use subscription filter policies to optimize messaging
- Cache content based on request headers
- Implement application-level caching to improve performance
- Optimize application resource usage
- Analyze application performance issues
- Use application logs to identify performance bottlenecks