AWS Certified Developer Associate Quick Facts (2025)

Exam Domain Breakdown

Domain 1: Development with AWS Services (32% of the exam)

Develop code for applications hosted on AWS

• Architectural patterns (event-driven, microservices, monolithic, choreography, orchestration, fanout)
• Idempotency
• Stateful and stateless concepts
• Differences between tightly coupled and loosely coupled components
• Fault-tolerant design patterns (retries with backoff, dead-letter queues)
• Synchronous and asynchronous patterns
• Writing and running unit tests in development environments
• Writing code to use messaging services and AWS SDKs
• Handling data streaming with AWS

Summary: In this section, the focus is on building applications that embrace cloud-native design. You will learn the differences between key architectural approaches such as monolithic versus microservices, as well as synchronous versus asynchronous communication. A big emphasis is placed on using patterns that create resilience, like retries with backoff or handling failed messages with dead-letter queues. The goal is to make sure your applications remain highly responsive, scalable, and fault-tolerant no matter the scenario.

Equally important is the ability to interact programmatically with AWS services. You’ll need to demonstrate familiarity with SDKs, APIs, and messaging services along with writing unit tests that ensure your code behaves correctly in a cloud environment. This means not only writing functional solutions but validating that they stand up to real-world use. This part of the exam rewards developers who think beyond code execution and focus on designing durable, testable, and maintainable solutions on AWS.

Develop code for AWS Lambda

• Event source mapping
• Stateless applications
• Event-driven architecture
• Configuring memory, concurrency, timeouts, layers, triggers, and destinations
• Error handling with Lambda Destinations and dead-letter queues
• Tuning Lambda performance
• Integrating Lambda functions with AWS services
• Writing and running test code using AWS tools

Summary: This section is designed to build your skills around AWS Lambda as a cornerstone of serverless design. You will gain knowledge of how to configure Lambda functions effectively, including adjusting resources, setting environment variables, and integrating with other AWS services. Understanding event-driven principles, stateless executions, and integration triggers is key to building smooth-running, responsive workloads.

Beyond configuration, you’ll develop proficiency in error handling strategies like using Lambda Destinations and dead-letter queues to ensure application resilience. You'll also enhance your awareness of performance and scalability in serverless workloads by tuning concurrency and optimizing usage. Altogether, you will show that you can design Lambda applications that are efficient, reliable, and seamlessly integrate within a broad AWS ecosystem.

Use data stores in application development

• Relational and non-relational databases
• CRUD operations
• Partitioning strategies including high-cardinality partition keys
• Database consistency models
• DynamoDB keys and indexing
• Query vs. scan operations
• Caching strategies (write-through, read-through, lazy loading, TTL)
• S3 tiers and lifecycle management
• Ephemeral vs. persistent storage patterns
• Using and managing data stores, lifecycles, and caches

Summary: Here you will explore the power of data management in AWS applications, both relational and non-relational. This includes relational solutions like Amazon RDS and Aurora, as well as DynamoDB for high-performance NoSQL workloads. You’ll understand partitioning strategies, indexing options, and consistency models, as well as choosing when to use efficient queries versus broader scans. By applying caching strategies, you demonstrate a clear ability to improve performance for applications that rely on data-intensive operations.

In addition to datastore access, you’ll be expected to recognize the differences between ephemeral and persistent storage and when to use each. Tools like lifecycle management in S3 or Time To Live expiration in caches show that you can build adaptive and cost-optimized storage solutions. This knowledge ensures that applications use their data layer thoughtfully, respecting trade-offs between cost, availability, and performance while keeping user needs central.

Domain 2: Security (26% of the exam)

Implement authentication and/or authorization

• Identity federation (SAML, OIDC, Amazon Cognito)
• Bearer tokens (JWT, OAuth, STS)
• User pools and identity pools in Cognito
• Policy types (resource-based, service, principal)
• Role-based access control and ACLs
• Principle of least privilege
• AWS managed vs. customer-managed policies
• Programmatic access and authenticated calls

Summary: This section showcases your ability to keep applications secure through identity management, policies, and federated access. You will practice evaluating scenarios for when to use Cognito identity pools, SAML, OIDC, or access tokens like JWT. By mastering role-based access control and policy design, you demonstrate that you can balance functionality with least privilege security principles.

From writing secure policy definitions to integrating authentication into application logic, this component reflects your skill in embedding security at every stage of software design. Your ability to integrate federated identities and fine-tune permissions ensures applications remain accessible only to the right entities while maintaining a seamless user experience.

Implement encryption by using AWS services

• Encryption at rest and in transit
• Certificate management with AWS Certificate Manager or Private CA
• Key protection including rotation strategies
• Client-side vs. server-side encryption
• AWS managed vs. customer-managed keys
• Using keys for encryption and decryption across accounts

Summary: In this section you will validate your ability to secure data at every stage of its lifecycle. You’ll learn when to apply encryption at rest with solutions like KMS or when to use encryption in transit for communication across networks. Certificate and key management are crucial, from understanding rotation practices to recognizing the differences between client- and server-side approaches. Managing how and when to rely on AWS-provided keys versus customer-managed keys is another central concept.

Beyond knowing the features of encryption services, you’ll apply them thoughtfully in real application environments. Whether encrypting objects in S3, securing API calls, or rotating keys for compliance standards, you will showcase that your implementations protect sensitive information and align with industry best practices. These skills highlight your readiness to design applications that are inherently trustworthy and compliant.

Manage sensitive data in application code

• Data classification (PII, PHI)
• Environment variables
• Secrets management (AWS Secrets Manager, Parameter Store)
• Secure credential handling
• Encrypting and sanitizing confidential data

Summary: Handling sensitive information inside applications requires strong discipline, and this section ensures you know how to achieve higher-grade protection. You’ll learn about data classification and how to safeguard personally identifiable information or protected health information. Using environment variables, secured credential storage, and secrets management services like Parameter Store and Secrets Manager are vital practices to master.

You’ll also focus on encrypting sensitive settings such as configuration values and applying sanitization practices to enforce safety throughout application lifecycle. These capabilities give businesses confidence that sensitive customer and application information is always shielded, allowing developers to enable innovation while protecting the trust of their users.

Domain 3: Deployment (24% of the exam)

Prepare application artifacts for deployment

• Access application configuration data (AppConfig, Secrets Manager, Parameter Store)
• Knowledge of Lambda packaging, layers, and options
• Knowledge of Git-based workflows
• Container images and code packaging strategies
• Organizing directories, dependencies, and runtime settings

Summary: This section validates your ability to prepare deployable application code packages. You’ll learn how to package Lambda functions with layers, include dependencies, and organize configuration artifacts with services like AppConfig and Secrets Manager. Managing container images and repositories also ensures your application packages are both secure and repeatable for consistent deployments.

You’ll also practice structuring directory layouts and code dependencies for easy configuration. Whether the target is serverless, containerized, or a hybrid workload, this section ensures you build artifacts that can be reliably deployed in staging, testing, or production pipelines without friction.

Test applications in development environments

• Features in AWS services that allow code deployment testing
• Integration testing with mock endpoints
• Lambda versions and aliases
• Testing APIs with mock integrations
• Using AWS SAM templates for validation

Summary: A strong application testing foundation is the hallmark of this section. You’ll demonstrate how to test deployed code using AWS services, from Lambda test events to mocked APIs in API Gateway. Integration testing and validation ensure that your changes function in isolation before reaching users, minimizing the risk of surprises later. You will also manage Lambda versions and aliases to separate environments logically.

In addition, this component prepares you to use infrastructure as code templates like SAM for multi-environment validation. Testing practices here set the stage for agile and iterative development, giving teams the freedom to deliver updates more often with greater confidence.

Automate deployment testing

• Continuous integration and delivery workflows
• API Gateway stages and environment branching
• Automated testing practices like unit and mock testing
• Creating and managing application test events
• Using aliasing and environment versions for staging

Summary: This section spotlights automation in deployment and testing. You’ll understand how CI/CD pipelines bring together testing practices, deployment workflows, and release management while minimizing manual overhead. You’ll orchestrate automated testing across environments, including unit and mock validation for Lambda and staging branches in Amplify or API Gateway.

By mastering automated workflows, you show that applications can remain reliable through rapid and frequent deployments. This transforms the way code is pushed to production, introducing efficiencies in iteration, visibility, and quality assurance.

Deploy code by using AWS CI/CD services

• Knowledge of Git-based tools and version control
• Using CI/CD services like SAM, CloudFormation, CDK, CodePipeline, Copilot, and Amplify
• Deployment strategies such as blue/green and canary
• Managing environments logically with API Gateway stages and custom domains
• Rollback, update, and release management options

Summary: This section highlights deploying code through automated CI/CD pipelines with AWS services. You’ll learn how to integrate version control check-ins with build and deployment workflows while using deployment strategies like blue/green, rolling, or canary to minimize downtime. You’ll also demonstrate skills with services such as CodePipeline, CloudFormation, or SAM to apply infrastructure and application changes consistently.

Crucially, you’ll ensure deployments are resilient and reversible, with clear rollback and release management strategies. This confirms you can keep environments stable while still rolling out improvements at speed across multiple teams and environments.

Domain 4: Troubleshooting and Optimization (18% of the exam)

Assist in a root cause analysis

• Logging and monitoring systems
• Debugging and interpreting logs or metrics
• SDK exceptions and HTTP codes
• Service maps in AWS X-Ray
• Debugging deployment issues with logs

Summary: This section equips you with the ability to find and fix issues through logs, traces, and metrics. You’ll interpret logs across CloudWatch, query them for insights with Logs Insights, and use application service maps in AWS X-Ray to pinpoint where issues originate. From debugging SDK exceptions to reading HTTP error codes, the core of this section is about resolving problems with clarity and confidence.

By combining diagnostic tools and hands-on debugging of application behavior, you will demonstrate the skills needed to recover quickly from anomalies. This evidence of troubleshooting ability reflects the way developers keep workloads healthy and stakeholders assured.

Instrument code for observability

• Distributed tracing
• Metrics and structured logging
• Adding annotations for services
• Implementing custom metrics
• Notification alerts linked to logs or resource activity

Summary: This section focuses on observability by applying structured logging, distributed tracing, and custom metrics. Using embedded metric formats and annotation strategies, you will extend the visibility of applications so teams can monitor behavior in granular detail.

In implementing notifications and insights derived from observability tools, you demonstrate proactive operations. This ensures that application health is actively monitored, optimizations are ongoing, and potential issues are surfaced before they impact users.

Optimize applications using AWS services and features

• Application performance profiling
• Caching strategies and optimizations
• Concurrency management
• SQS and SNS for optimized messaging patterns

Summary: This topic area validates your understanding of fine-tuning application logic and performance. You will improve efficiency through caching solutions, concurrency adjustments, and messaging optimizations with services like SQS and SNS. Performance profiling ensures the right balance between cost and resource allocation.

By applying optimization principles thoughtfully, this part of the exam demonstrates you can design cloud applications that are not only functional but streamlined for scale, responsiveness, and efficient resource use. This shows employers and teams that you not only design effectively but refine continuously for peak reliability.