Skip to main content

AWS Development

The AWS services the workload needs

We place an application on AWS by the way the work runs: Lambda for short requests, ECS or EKS for containers that stay up, and a written boundary for accounts, IAM, S3, and RDS.

Illustration for AWS development services

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.

  • Accounts and IAM

    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, ECS, and EKS

    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, RDS, and queues

    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.

  • Infrastructure in code

    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.

  • An event or HTTP handler on Lambda

    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.

  • A container service on ECS

    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.

  • Kubernetes that is a deliberate choice

    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.

  • A public site with private data

    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.

  • Fix the account and the network

    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.

  • Choose Lambda, ECS, or EKS for a reason

    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.

  • Describe it in the tool you will keep

    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.

  • Rehearse the deploy and the rollback

    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.

Our AWS work

  • Client project, live in production

    Gmail-native outreach and thread tracking for a client platform

    Our client's users needed to email their contacts without leaving the platform, and then copy replies back into it by hand, which was slow and error-prone. We built a Gmail integration that lets them start conversations from the app's own interface, using their own Google Workspace accounts. Every reply, forward and new participant on those threads is then captured, analyzed and saved automatically, with no extra work.

    Privacy by design. Users connect their Gmail account once, through Google-verified OAuth with sensitive-scope permissions. The app never reads the inbox: it only follows threads the user started through the app, and ignores everything else.

    • Gmail API. Sending as the user and receiving change notifications
    • Cloud Pub/Sub. Streams inbox events to the backend for asynchronous processing
    • Google Cloud IAM. Service-account credentials securing every Google-side call
    • OpenTofu. Infrastructure-as-code templates for the Google Cloud environment, reproducible and version-controlled
    • AWS Lambda + API Gateway. The client's serverless backend, receiving Google Cloud events and processing them
    • PostgreSQL. A complete record of every tracked thread and its activity

Bring the runtime you have in mind

Lambda, a container, or a cluster. We will match it to an account layout, a data store, and a template you can apply again.

Schedule a call

Why OLIANT

AWS at OLIANT is a short list of services, an IAM boundary, and a template that can rebuild the environment.

  • Compute follows the work

    Lambda, ECS, or EKS is a decision about duration and operations. It is written down with the template.

  • Accounts mean environments

    Identity and network boundaries separate staging from production. A shared admin key is not the deployment plan.

  • The console is not the source

    CDK, CloudFormation, or Terraform holds the stack. A click in the console is either imported or reverted.

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.

An AWS stack you can apply twice

Tell us the workload and the account you have. We will name the compute, the data services, and the template.

Illustration for the AWS development closing invitation