TL;DR
- Start serverless on AWS: Lambda behind API Gateway, DynamoDB for most data, TypeScript everywhere, and every resource in AWS CDK.
- Move a workload to ECS on Fargate when it runs steadily all day, or longer than a function can.
- Use Kubernetes (EKS) only when a client requires it.
- Five questions decide when a default should bend: how long a job runs, the shape of the load, the shape of the data, any platform a client or regulation requires, and who runs the system after launch.
Recently I have read many posts and articles about how to choose a tech stack: whether to use containers, which frontend stack to pick, and so on. So I want to share what we have used in our projects, and our preferences. Because it comes from real projects, I also say for each default where it stops fitting, and I think that part matters more than the default itself. A default is only useful if you know its limit.
It helps to know where we stand before you read our view. At INNOMIZE we run standard Lambda functions in production, and every resource we deploy is defined in AWS CDK. We run one project on EKS with Argo CD, because that system needs Kubernetes, and the same system also runs as a full copy on a small VM with Docker Compose. Some items below are our next step, and I mark them as such: WorkOS is the next sign-in adapter after Cognito, and we have not used Lambda Web Functions, MicroVMs or Managed Instances, so for those three the facts come from AWS documentation.
Why AWS, and why one cloud
We chose AWS because of our team's experience and because it is widely used in the industry. The team already knows the services, which means we start building sooner and spend less time on the platform itself.
We also decided to go deep on one cloud instead of spreading across several. I do not think multi-cloud is worth it for most teams. You need two sets of skills, two sets of infrastructure code and two sets of billing, and you pay for all of that every month, while the lock-in it protects you from may never arrive. Vendor lock-in is a real risk, but in my experience it is rarely the problem a team actually has.
We still keep two places where switching would be cheap. Sign-in sits behind an adapter, and telemetry goes out over OpenTelemetry, so the backend can change. If a client ever needed a different cloud or identity provider, those two places are where we would start.
Five questions first
We ask these five before we pick anything. They work for a new product and for an existing one.
- How long does one request or job run, at the longest?
- Is the load steady all day, or does it come in bursts?
- Does the data need joins or transactions across many entities?
- Does a client or a regulation require a specific platform, such as Kubernetes?
- Who on the team will run this after launch, and how many hours a month can they give it?
If your answers are short runs, bursty load, simple data and a small team, the defaults below fit as they are. Any other answer sends you to a different row of the table, and the last column tells you which one.
The defaults, layer by layer

The table lists each layer with our default, the tool we use for it and the condition that should make you choose something else. The rest of the post explains the reasoning behind the rows that people ask about most.
| Layer | Our default | Tool we use | Choose something else when |
|---|
| Language | TypeScript on Node.js 24 | Node.js 24, Lambda nodejs24.x. We move to 26 once Lambda's nodejs26.x is generally available | A team already runs a strong runtime in another language and has no reason to switch |
| Frontend | Static export on object storage behind a CDN | Next.js App Router, CloudFront | You need server rendering on every request, or per-request data the static build cannot hold |
| HTTP | Route tables bound to NestJS, with OpenAPI generated from them | NestJS 12, Zod 4 for the contract | You want no framework for HTTP, or the service is small enough that routing is a few lines |
| Data, most access | Key-value store | DynamoDB through the AWS SDK v3, no ORM | Your queries need joins, ad-hoc relational queries, or transactions across many entities |
| Data, relational | Relational database for joins and transactions | Aurora PostgreSQL Serverless v2, Kysely, Liquibase | Your data is mostly key lookups, and a relational database only adds operations work |
| Cache | Managed Redis-compatible store | Valkey locally, a managed store in deployments | Reads are fast enough without one, or nobody has measured the need |
| Full-text search | Only when a module needs it | Amazon OpenSearch Service | Search fits the database, or the data is small enough to filter in code |
| Compute | Lambda first, ECS on Fargate for steady work, EKS only on client requirement | Lambda, ECS on Fargate, EKS with Argo CD | Steady load, long runs, or a runtime limit you hit |
| Infrastructure | AWS CDK in TypeScript for every resource | AWS CDK | The organisation already standardises on another IaC tool |
| Delivery | One reusable deploy workflow per runtime type | GitHub Actions reusable workflows, Gitflow branches | Your code or release process lives somewhere else |
| Auth | Managed identity provider for credentials, server-side sessions, CASL for permissions | Cognito first, WorkOS next for enterprise SSO. Firebase Authentication, Supabase Auth, Keycloak or Better Auth when a project calls for it | A customer needs a provider we have not adapted yet |
| Observability | Structured logs to stdout, OpenTelemetry over OTLP | OpenTelemetry SDK. Backend per project: SigNoz, OpenObserve, Datadog, or Grafana OSS on Kubernetes | The telemetry has to stay on a platform we already run, or a client picks it |
How the pieces meet

A user loads the frontend from object storage through CloudFront. The page is a static build, so there is no server to render it on each request and nothing to scale when traffic grows. The page calls the API through API Gateway, and behind it sits a Lambda function, or an ECS service when the workload runs steadily. Most of the data lives in DynamoDB. The data that needs joins or transactions goes to Aurora PostgreSQL Serverless v2, and a deployment can use RDS for PostgreSQL instead. Short-lived data that many requests read sits in a Redis-compatible store, which on AWS is ElastiCache, now with Valkey support.
Events come out of the database, not out of the application code. Each write stores its event as an outbox row in the same transaction, so the event exists only if the change does. This is the transactional outbox pattern, a general pattern rather than an AWS feature. A DynamoDB stream reads those rows and sends them to EventBridge, which routes each event to a queue per consumer, and every queue has a dead-letter queue for messages that keep failing. Two things follow from this design. Delivery is at least once, so each consumer has to handle duplicates. And a stream keeps changes for 24 hours, so a relay that stays down longer than that loses events.
Long jobs run on the same queues. A function takes a job, and before it reaches its time limit it puts the rest of the work back on the queue, so no single run has to finish everything in one go.
Sign-in sits outside the data path. We put the identity provider behind an adapter, so changing provider does not change the business rules. Cognito is our default adapter, and WorkOS comes next for enterprise single sign-on. On other projects we have also used Firebase Authentication, Supabase Auth, Keycloak and Better Auth, and the adapter is what keeps a change of provider cheap. After sign-in the API uses a server-side session, and CASL decides what each user can do.
Every service sends logs, traces and metrics over OTLP to an OpenTelemetry collector, and keeps logs on stdout as a fallback. OpenTelemetry is the fixed part. The backend changes per project, and we have used SigNoz, OpenObserve, Datadog and Grafana OSS, the last one on Kubernetes.
Why serverless comes first, and where it stops
Serverless is our first choice because AWS runs the servers. A function starts when a request arrives, you pay for the time it runs, and nobody on the team patches a cluster or plans its capacity. For a small team that is most of the operations work gone before the first deploy.
For years the advice was that serverless suits short, bursty work and containers suit everything else. Lambda moved that line in 2026. Managed Instances take steady, heavier work, durable functions handle multi-step flows that wait, Web Functions run a web server without an adapter (Node.js only), and MicroVMs run isolated code. We have not used Web Functions, MicroVMs or Managed Instances yet, and our posts on the Lambda changes and choosing compute cover each one and its limits.
Serverless still stops fitting in two cases. One is steady load that runs all day, where the bill and the tuning can favour a container, and the compute post has the numbers. The other is a hard limit: a runtime, a timeout, or memory the function cannot reach, and Lambda's quotas list the figures. When we hit one, we move that workload to ECS on Fargate. We keep the managed platform and most of the deploy path, so the move is one service, not a new platform.
We do not give a price here. The cost depends on invocations, duration, how steady the load is, data transfer, and the hours someone spends running the result, so any single number would mislead more than it helps.
Kubernetes is the last step, and we take it only when a client requires it. Our project template does not set up EKS yet, so that path starts with a design decision. Each step down adds work the team has to own, such as cluster upgrades and node settings. Our earlier post on Lambda, Managed Instances, ECS and EKS covers that cost in more detail.
When not to follow this
Some teams should not start from this stack. A team with no AWS account and no plan for one needs a different cloud default, and a product with strict data residency rules may need a different database and deploy path.
For a working system, apply the defaults to new services first. Change one layer at a time, and only when one of the five questions gives you a reason. A team that already runs Kubernetes well can keep it for new services too.
Some layers are still open for us: code and dependency scanning, a browser end-to-end test tool, and offline storage. We would rather list them than hide them, and each one gets its own decision when it starts to cost time.
We start on Lambda and move to ECS only when a limit is hit. If your team went the other way, starting on containers and moving to Lambda later, which workload made you decide?
Further reading