AWS Certified Developer Associate Interactive Course

Architectural patterns

Idempotency

Differences between stateful and stateless concepts

Differences between tightly coupled and loosely coupled components

Fault-tolerant design patterns

Differences between synchronous and asynchronous patterns

Creating fault-tolerant and resilient applications in a programming language

Creating, extending, and maintaining APIs

Writing and running unit tests in development environments

Writing code to use messaging services

Writing code that interacts with AWS services by using APIs and AWS SDKs

Handling data streaming by using AWS services

Event source mapping

Stateless applications

Unit testing

Event-driven architecture

Scalability

The access of private resources in VPCs from Lambda code

Configuring Lambda functions by defining environment variables and parameters

Handling the event lifecycle and errors by using code

Writing and running test code by using AWS services and tools

Integrating Lambda functions with AWS services

Tuning Lambda functions for optimal performance

Relational and non-relational databases

Create, read, update, and delete operations

High-cardinality partition keys for balanced partition access

Cloud storage options

Database consistency models

Differences between query and scan operations

Amazon DynamoDB keys and indexing

Caching strategies

Amazon S3 tiers and lifecycle management

Differences between ephemeral and persistent data storage patterns

Serializing and deserializing data to provide persistence to a data store

Using, managing, and maintaining data stores

Managing data lifecycles

Using data caching services

Identity federation

Bearer tokens

The comparison of user pools and identity pools in Amazon Cognito

Resource-based policies, service policies, and principal policies

Role-based access control

Application authorization that uses ACLs

The principle of least privilege

Differences between AWS managed policies and customer-managed policies

Identity and access management

Using an identity provider to implement federated access

Securing applications by using bearer tokens

Configuring programmatic access to AWS

Making authenticated calls to AWS services

Assuming an IAM role

Defining permissions for principals

Encryption at rest and in transit

Certificate management

Key protection

Differences between client-side encryption and server-side encryption

Differences between AWS managed and customer managed AWS Key Management Service keys

Using encryption keys to encrypt or decrypt data

Generating certificates and SSH keys for development purposes

Using encryption across account boundaries

Enabling and disabling key rotation

Data classification

Environment variables

Secrets management

Secure credential handling

Encrypting environment variables that contain sensitive data

Using secret management services to secure sensitive data

Sanitizing sensitive data

Ways to access application configuration data

Lambda deployment packaging, layers, and configuration options

Container images

Managing the dependencies of the code module within the package

Organizing files and a directory structure for application deployment

Using code repositories in deployment environments

Git-based version control tools

Applying application requirements for resources

Features in AWS services that perform application deployment

Integration testing that uses mock endpoints

Lambda versions and aliases

Testing deployed code by using AWS services and tools

Performing mock integration for APIs and resolving integration dependencies

Testing applications by using development endpoints

Deploying application stack updates to existing environments

API Gateway stages

Branches and actions in the continuous integration and continuous delivery workflow

Automated software testing

Creating application test events

Deploying API resources to various environments

Creating application environments that use approved versions for integration testing

Implementing and deploying infrastructure as code templates

Managing environments in individual AWS services

Git-based version control tools

Manual and automated approvals in AWS CodePipeline

Access application configurations from AWS AppConfig and Secrets Manager

CI/CD workflows that use AWS services

Application deployment that uses AWS services and tools

Lambda deployment packaging options

API Gateway stages and custom domains

Deployment strategies

Updating existing IaC templates

Managing application environments by using AWS services

Deploying an application version by using deployment strategies

Committing code to a repository to invoke build, test, and deployment actions

Using orchestrated workflows to deploy code to different environments

Performing application rollbacks by using existing deployment strategies

Using labels and branches for version and release management

Using existing runtime configurations to create dynamic deployments

Logging and monitoring systems

Languages for log queries

Data visualizations

Code analysis tools

Common HTTP error codes

Common exceptions generated by SDKs

Service maps in AWS X-Ray

Debugging code to identify defects

Interpreting application metrics, logs, and traces

Querying logs to find relevant data

Implementing custom metrics

Reviewing application health by using dashboards and insights

Troubleshooting deployment failures by using service output logs

Distributed tracing

Differences between logging, monitoring, and observability

Structured logging

Application metrics

Implementing an effective logging strategy to record application behavior and state

Implementing code that emits custom metrics

Adding annotations for tracing services

Implementing notification alerts for specific actions

Implementing tracing by using AWS services and tools

Caching

Concurrency

Messaging services

Profiling application performance

Determining minimum memory and compute power for an application

Using subscription filter policies to optimize messaging

Caching content based on request headers