AWS Certified Developer – Associate (DVA-C02)

For IT leaders: Teams moving workloads to serverless and containers often ship code faster than they can secure, test, and monitor it. The results are misconfigured IAM roles, Lambda functions that can't reach private databases, and outages that are hard to diagnose. This course gives developers a shared, exam-aligned way to build on AWS.

Role fit: Assign this to software developers and cloud engineers with 1+ years of hands-on AWS experience. It also helps Team Leads standardize how their group uses SAM, CodePipeline, and CloudWatch.

Time investment: Plan for about 34 hours across 35 skills, most under an hour. Learners can work through it in focused weekly blocks without pulling them off delivery work.

Risk and compliance: Dedicated skills cover IAM roles and policies, encryption at rest, log planning with security in mind, and monitoring across AWS services. That gives teams a clearer path to audit-ready practices.

Change management: Expect workflow shifts. The course teaches Git branching in CodeCommit, CI/CD with CodePipeline, infrastructure-as-code testing with TaskCat, unit and integration tests for Lambda, and production rollout strategies such as canary stages.

How it's delivered: Instructor Knox Hutchinson builds, deploys, and debugs working solutions on screen and shares follow-along code samples. Because the course is modular, IT Directors can assign the full DVA-C02 path or target specific gaps, such as VPC-connected Lambda or CloudWatch monitoring.

IT teams use this training to ship serverless and container workloads that hold up under production traffic, not just in a sandbox. Instructor Knox Hutchinson builds real projects end to end: scaffolding SAM projects with sam init, deploying with sam deploy --guided, then checking CloudFormation to confirm that resources, roles, and permissions actually landed before testing how API Gateway talks to Lambda and writes to S3.

The course also takes on the problems that slow delivery teams down. Developers connect Lambda to RDS on private subnets and work through the common gotchas: execution roles, VPC endpoints, and security groups that must line up before a function can reach a private database. For release safety, the course shows how enterprises test with real production traffic through canary stages that route a percentage of requests to new features before full rollout.

• Safer releases: Use canary deployments and CI/CD pipelines with CodePipeline and TaskCat to catch problems before they affect every user.
• Fewer connectivity outages: Troubleshoot Lambda-to-VPC and RDS access in a methodical way, one layer at a time.
• Decoupled, resilient apps: Build SQS producer and poller patterns and SNS fanout topics that serve application and human subscribers at the same time.
• Faster incident triage: Start with AWS service status, then move into CloudWatch metrics and planned logging, so the team can quickly tell a bad deploy apart from a platform issue.

Team Leads get developers who can build, test, and debug on AWS with the same habits used in production environments.

Knowledge

• How Lambda functions are invoked synchronously and asynchronously, how event sources and filtering work, and how SAM templates package Lambda, API Gateway, and S3 into CloudFormation deployments
• When to choose REST versus WebSocket APIs in API Gateway, including stages and canary releases that send a share of production traffic to new features
• How SQS producer and consumer patterns and SNS fanout topics decouple microservices and send alerts to people and applications
• When to use DynamoDB, RDS, S3, Timestream, or a cache, plus lazy loading and write-through caching strategies
• How IAM authentication, authorization, roles, and policies control access, and how encryption at rest, CloudWatch, and logging plans support secure operations
• How Git, CodeCommit branching, CodePipeline, and deployment strategies move code from dev and test into production

Ability

• Scaffold, validate, and deploy serverless applications with the SAM CLI (sam init, sam deploy --guided), then confirm the resources and permissions in CloudFormation
• Connect Lambda functions to RDS databases and caches on private VPC subnets with the right execution roles, security groups, and VPC endpoints
• Register container images in ECR and deploy them to ECS, including additional deployment configuration and orchestration with Docker Compose
• Query DynamoDB items and attributes and use batch operations to improve efficiency
• Build CI/CD pipelines with CodePipeline and Elastic Beanstalk, define infrastructure as code with templates, and write unit and integration tests for Lambda
• Troubleshoot issues by checking AWS service status first, then CloudWatch metrics and logs, and stream logs to S3 in real time