AWS Developer

Applications on AWS are mostly wiring. You connect APIs, queues, topics, events and workflows into a working application, and learn the delivery behavior and failure modes of each connection.

• REST and HTTP APIs with API Gateway
• Queues with SQS: visibility, batching and dead letters
• Topics and fan-out with SNS
• Event routing with EventBridge
• Workflows with Step Functions
• Hosting containers on ECS and Fargate

You build An order-processing application built from an API, a queue and a workflow.

Lambda looks simple until traffic arrives. You package and configure functions, understand concurrency and invocation types, and handle failures, versions and releases correctly.

• Handler structure and execution environment
• Event sources and invocation types
• Concurrency, scaling and cold starts
• Error handling, retries and dead-letter queues
• Versions, aliases and gradual deployment
• Layers, environment variables and packaging

You build A set of Lambda functions with error handling, aliases and a gradual release.

Where data lives shapes how code is written. You model DynamoDB tables around queries, handle S3 safely at scale, connect to relational databases without exhausting them, and cache the right things.

• DynamoDB keys, indexes and consistency
• Conditional writes, transactions and streams
• S3 presigned URLs and multipart upload
• Connection handling with RDS Proxy
• Caching strategies with ElastiCache
• Choosing between data stores while building

You build A data layer for one application using DynamoDB, S3 and a cache.

Users and services must prove who they are before your code trusts them. You add user sign-in with Cognito, protect APIs with authorizers, and give code the narrowest role it needs.

• Cognito user pools and identity pools
• Tokens: JWT claims and validation
• API Gateway and Lambda authorizers
• IAM roles and policies for application code
• Temporary credentials with STS
• Service-to-service authorization

You build A sign-in flow with an API that authorizes each request.

Application code often handles data it should never log. You encrypt in your application and in storage, manage keys and secrets, and keep sensitive values out of code, logs and error messages.

• Envelope encryption with KMS
• Secrets Manager and Parameter Store
• Encrypting data in transit
• Client-side and server-side encryption choices
• Masking sensitive data in logs
• Rotating secrets without downtime

You build An application that stores secrets safely, encrypts records and logs without exposing data.

Adding a model to an application adds new ways to fail. You call managed models from your code, validate what comes back, defend against prompt injection and limit what a model-connected function may do.

• Calling foundation models from Lambda and applications
• Treating model output as untrusted input
• Prompt injection and data leakage
• Least-privilege roles for model-connected code
• Rate limits, timeouts and cost controls
• Guardrails and content filtering

You build A model-backed endpoint with output validation, limits and injection tests.

What you ship must be the same thing you tested. You package code and containers reproducibly, separate configuration from code, and write tests that run against real service behavior.

• Packaging code, dependencies and container images
• Configuration with AppConfig and environment settings
• Unit tests with mocked AWS services
• Integration tests against deployed resources
• Test events and local invocation
• Managing multiple environments

You build A tested package with unit and integration tests and per-environment configuration.

Deployments should be dull and repeatable. You build pipelines with CodeBuild, CodePipeline and CodeDeploy, deploy templates with SAM and CloudFormation, and release gradually with the ability to undo.

• Build specifications with CodeBuild
• Pipelines with CodePipeline
• CodeDeploy strategies for Lambda, ECS and EC2
• SAM and CloudFormation deployments
• Gradual releases and automatic rollback
• Managing secrets in pipelines

You build A pipeline that builds, tests and deploys a serverless application with rollback.

When something breaks you need evidence. You write structured logs, publish metrics, trace requests across services and read the signals to find root causes instead of guessing.

• Structured logging and Logs Insights
• Custom metrics and alarms
• Distributed tracing with X-Ray
• Correlating logs, metrics and traces
• Common failure patterns in serverless and containers
• Writing a root cause summary

You build An observability setup for one application and a root cause analysis of an injected fault.

Small design choices change latency and bill. You tune memory and concurrency, reduce calls with caching and batching, reuse connections and measure each change.

• Lambda memory, timeout and concurrency tuning
• Caching at API, application and data layers
• Batching and reducing round trips
• Connection reuse and initialization costs
• Profiling to find the slow call
• Cost-aware design in code

You build A measured optimization of one slow endpoint with before-and-after numbers.

Build one application end to end. You design, code, secure, test, deploy and observe a service with user sign-in, a data store and an AI feature, then diagnose a fault you did not plan.

• Scoping and designing the application
• Building and securing the services
• Testing and deploying through a pipeline
• Observing it and finding an injected fault
• Presenting the design and trade-offs

You build A deployed serverless application with sign-in, data, an AI feature and monitoring.