What a Modern Development Stack Looks Like in 2026

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.

  1. How long does one request or job run, at the longest?
  2. Is the load steady all day, or does it come in bursts?
  3. Does the data need joins or transactions across many entities?
  4. Does a client or a regulation require a specific platform, such as Kubernetes?
  5. 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 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.

LayerOur defaultTool we useChoose something else when
LanguageTypeScript on Node.js 24Node.js 24, Lambda nodejs24.x. We move to 26 once Lambda's nodejs26.x is generally availableA team already runs a strong runtime in another language and has no reason to switch
FrontendStatic export on object storage behind a CDNNext.js App Router, CloudFrontYou need server rendering on every request, or per-request data the static build cannot hold
HTTPRoute tables bound to NestJS, with OpenAPI generated from themNestJS 12, Zod 4 for the contractYou want no framework for HTTP, or the service is small enough that routing is a few lines
Data, most accessKey-value storeDynamoDB through the AWS SDK v3, no ORMYour queries need joins, ad-hoc relational queries, or transactions across many entities
Data, relationalRelational database for joins and transactionsAurora PostgreSQL Serverless v2, Kysely, LiquibaseYour data is mostly key lookups, and a relational database only adds operations work
CacheManaged Redis-compatible storeValkey locally, a managed store in deploymentsReads are fast enough without one, or nobody has measured the need
Full-text searchOnly when a module needs itAmazon OpenSearch ServiceSearch fits the database, or the data is small enough to filter in code
ComputeLambda first, ECS on Fargate for steady work, EKS only on client requirementLambda, ECS on Fargate, EKS with Argo CDSteady load, long runs, or a runtime limit you hit
InfrastructureAWS CDK in TypeScript for every resourceAWS CDKThe organisation already standardises on another IaC tool
DeliveryOne reusable deploy workflow per runtime typeGitHub Actions reusable workflows, Gitflow branchesYour code or release process lives somewhere else
AuthManaged identity provider for credentials, server-side sessions, CASL for permissionsCognito first, WorkOS next for enterprise SSO. Firebase Authentication, Supabase Auth, Keycloak or Better Auth when a project calls for itA customer needs a provider we have not adapted yet
ObservabilityStructured logs to stdout, OpenTelemetry over OTLPOpenTelemetry SDK. Backend per project: SigNoz, OpenObserve, Datadog, or Grafana OSS on KubernetesThe telemetry has to stay on a platform we already run, or a client picks it

How the pieces meet

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

Nov 11, 2026

Similar articles

Scaling and Integrating Health Management Solutions: Overcoming Tech Challenges in Healthcare

See how INNOMIZE helped a health platform overcome technical challenges to improve scalability, integration, and user experience in managing chronic conditions.

How To Set Up A Multi-version Odoo Development Environment Locally

Configuring the local development environment to run multiple versions of Odoo that need different versions of Python dependencies

Long-running Serverless Web Scraping – An AWS Well-architected Solution

Nowadays, there are many tools that can help you implement the web scraping solution. But crawling websites with a large dataset and complex sitemap take longer and require servers to run the scraping process. This article will describe how to build and run the headless web scrapping on the AWS applying IaC and Serverless computing