What we build on AWS
AWS has many services. A project uses the small set that matches the workload, described in code so the next environment is not a click-through.

Environments are separate accounts when the organization can support that, and separate IAM boundaries inside an account when it cannot. Roles are assumed. Long-lived access keys are not how a person logs in, and they are not how a service authenticates if a role will do.
The pipeline role can deploy what it owns. It cannot read another environment because the names happen to match.

Lambda fits a request or an event that finishes quickly and can tolerate a cold start. ECS fits a container you want running, on Fargate or on instances you already operate. EKS fits a team that has chosen Kubernetes and will run the cluster.
API Gateway or an application load balancer is the front door when the service needs one. CloudFront sits in front of public static assets and, when it helps, in front of the HTTP entry.

S3 holds objects, with a bucket policy and a lifecycle for the data that should expire. RDS holds relational data, in the engine the application already speaks, in a private subnet. SQS or SNS carries work that must outlive the request.
The application receives permission for its bucket and its database. A wildcard on the account is a defect.

CloudFormation, AWS CDK, or Terraform describes the stack. The format is the one the team will edit. A console change that is not imported back into that description does not count as done.
Logs go to CloudWatch with a retention. Alarms cover the failure you would page on, not every metric the service happens to emit.
Typical use cases
The right AWS shape depends on how long the work runs and who will operate it.

A webhook, a file arriving in S3, or a short API method. The function has a timeout, a role, and a test that invokes it with the event it will really receive.

An API that stays up, with a task definition, a target group, and a deploy that replaces tasks. Fargate when you do not want to patch instances. EC2-backed ECS when you already run the hosts.

EKS for a platform team with more than one service and a reason to share a cluster. Namespaces and IAM roles for service accounts are part of the first deploy, not a later cleanup.

CloudFront and S3 for the public assets. The API and RDS stay in private subnets. The browser never receives a path to the database, and the bucket is not the application log store.
How we work
We name the account boundary and the compute model before we add services. Extra AWS products have to pay for their operational cost.

Which account, which VPC, which subnets are public. The application's security groups are written to the destinations it calls. A wide-open security group is not a temporary step we leave in the template.

The reason is duration, deploy style, and who patches the platform. We record it next to the template. A second compute model inside the same service needs its own justification.

CDK, CloudFormation, or Terraform. One of them. Parameters cover the differences between environments. Secrets live in Secrets Manager or Parameter Store, referenced by the task, not pasted into a task definition.

Staging is another account or another isolated stack, built from the same template. We deploy there, check the health endpoint, and roll back once so production is not the first time the rollback path runs.
Frequently asked questions
Questions we answer before choosing AWS services.
No. Lambda is the right tool for short, event-driven work. A service that stays warm, holds a connection pool, or takes a long time belongs on ECS or another container runtime. We choose after looking at the work.
Yes. We use your AWS Organizations structure, your VPCs, and your pipeline. New stacks land in the account you designate, with roles that fit the permission model you already enforce.
The one your team will edit. CloudFormation, AWS CDK, or Terraform. We do not introduce a second tool beside a stack you already maintain.
They are separate pages because the identity model and the product names differ. We can run a piece of a system on AWS and another piece elsewhere, with an explicit contract between them. The application itself is described under custom development and the language pages.