AWS Certified Developer - Associate

Basic AWS service concepts, regions, availability zones, and how services communicate

• Configure programmatic access to AWS
• Define permissions for IAM principals

• Write code that interacts with AWS services by using APIs and AWS SDKs
• Make authenticated calls to AWS services

• Assume an IAM role

• 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

• Define encryption at rest and in transit
• Describe differences between client-side encryption and server-side encryption

• Describe certificate management (for example, AWS Private CA)

• Use encryption keys to encrypt or decrypt data
• Enable and disable key rotation

• Describe data classification (for example, personally identifiable information [PII], protected health information [PHI])
• Sanitize sensitive data

• Encrypt environment variables that contain sensitive data
• Use secret management services to secure sensitive data

• Configure Lambda functions by defining environment variables and parameters (for example, memory, concurrency, timeout, runtime, handler, layers, extensions, triggers, destinations)

• Integrate Lambda functions with AWS services
• Handle the event lifecycle and errors by using code (for example, Lambda Destinations, dead-letter queues)

• Describe the access of private resources in VPCs from Lambda code

• Create, extend, and maintain APIs (for example, response/request transformations, enforcing validation rules, overriding status codes)

• Describe API Gateway stages and custom domains

• Write code to use messaging services

• Use subscription filter policies to optimize messaging

• Use Amazon EventBridge to implement event-driven patterns

• Handle streaming data using AWS services
• Use Lambda functions to process and transform data in near real time

• Define Amazon DynamoDB keys and indexing
• 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

• 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)

• Create fault-tolerant and resilient applications in a programming language (for example, Java, C#, Python, JavaScript, TypeScript, Go)
• Implement resilient application code for third-party service integrations (for example, retry logic, circuit breakers, error handling patterns)

• Use an identity provider to implement federated access (for example, Amazon Cognito, IAM)
• Secure applications by using bearer tokens

• Implement application-level authorization for fine-grained access control
• Handle cross-service authentication in microservice architectures

• Implement data access patterns for multi-tenant applications

• Use encryption across account boundaries

• Generate certificates and SSH keys for development purposes

• Implement application-level data masking and sanitization

• Write and run unit tests in development environments (for example, using AWS SAM)

• Use code repositories in deployment environments
• Use labels and branches for version and release management

• 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

• Describe Lambda deployment packaging options

• Apply application requirements for resources (for example, memory, cores)

• Prepare application configurations for specific environments (for example, by using AWS AppConfig)

• Implement and deploy infrastructure as code (IaC) templates (for example, AWS SAM templates, AWS CloudFormation templates)

• Update existing IaC templates (for example, AWS SAM templates, CloudFormation templates)

• Manage environments in individual AWS services (for example, differentiating between development, test, and production in API Gateway)
• Manage application environments by using AWS services

• Create application test events (for example, JSON payloads for testing AWS Lambda, API Gateway, AWS SAM resources)

• Write integration tests and mock APIs for external dependencies
• Test applications by using development endpoints (for example, configuring stages in Amazon API Gateway)

• Test deployed code by using AWS services and tools
• Write and run test code by using AWS services and tools

• Test event-driven applications

• Create application environments that use approved versions for integration testing (for example, Lambda aliases, container image tags, AWS Amplify branches, AWS Copilot environments)

• Deploy API resources to various environments

• Deploy application stack updates to existing environments (for example, deploying an AWS SAM template to a different staging environment)

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

• Describe differences between logging, monitoring, and observability

• Implement an effective logging strategy to record application behavior and state
• Implement structured logging for application events and user actions

• Query logs to find relevant data

• Implement custom metrics (for example, Amazon CloudWatch embedded metric format [EMF])
• Implement code that emits custom metrics

• Add annotations for tracing services
• Implement tracing by using AWS services and tools

• Configure application health checks and readiness probes

• Implement notification alerts for specific actions (for example, notifications about quota limits or deployment completions)

• Interpret application metrics, logs, and traces

• Review application health by using dashboards and insights

• Debug code to identify defects

• Troubleshoot deployment failures by using service output logs

• Debug service integration issues in applications

• Define concurrency

• Profile application performance
• Determine minimum memory and compute power for an application

• Tune Lambda functions for optimal performance

• 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

• Use Amazon Q Developer to assist with development

• Use Amazon Q Developer to generate automated tests