Amazon EKS Auto Mode: What AWS Manages, What It Costs and How to Migrate

On this page

Running Kubernetes on Amazon EKS has always meant running two things: the workloads, and the nodes under them. AWS has managed the control plane since EKS launched, but node provisioning, AMI updates, the VPC CNI, the EBS CSI driver and the load balancer controller were the cluster owner’s job. EKS Auto Mode, announced and made generally available at re:Invent on 1 December 2024, moves that layer to AWS. It works on new and existing clusters running Kubernetes 1.29 or later, and launched in all AWS Regions except AWS GovCloud (US) and China.

A little over a year on, the useful questions are specific. What exactly does AWS take over, and what stays with you? How do you shape the nodes it launches? What does it cost compared with managed node groups or your own Karpenter? And which existing manifests break when you switch? This article answers those as of February 2026, with a tested set of starter manifests and a linter that flags what has to change in an existing cluster’s YAML.

What AWS takes over

EKS Auto Mode responsibility split: AWS manages node provisioning and scaling, node OS and patching, networking and block storage and load balancing; the customer manages NodePools and NodeClasses, workloads, access and identity, and other add-ons
Auto Mode moves the data plane to AWS. NodePools, workloads and access control stay with you.

With Auto Mode enabled, AWS runs a set of capabilities for the cluster outside your worker nodes: compute autoscaling based on Karpenter, pod and service networking with network policy, Elastic Load Balancing for Application and Network Load Balancers, EBS block storage, cluster DNS, GPU support and node health checks. You do not install or upgrade those components, and they do not consume capacity on your nodes.

The nodes themselves are EC2 instances in your account, but AWS manages them. They run a Bottlerocket-based AMI with a read-only root file system and SELinux enforcing, SSH and SSM access are blocked, and each node has a maximum lifetime of 21 days, after which it is replaced. New AMIs roll out by replacing nodes, not by patching them in place, so PodDisruptionBudgets and topology spread constraints decide how smoothly that happens.

ℹ️
BUILT-IN NODEPOOLS

Auto Mode can create two NodePools for you: system, for cluster-critical add-ons, and general-purpose, for everything else, both using a default NodeClass. They are a good start, but do not edit them; add your own NodePools and NodeClasses next to them when you need different instance types, subnets or capacity types.

Shaping the nodes

Auto Mode keeps Karpenter’s NodePool resource (karpenter.sh/v1) for scheduling rules, limits and disruption, and replaces Karpenter’s EC2NodeClass with its own NodeClass (eks.amazonaws.com/v1) for AWS settings. The NodeClass is smaller than Karpenter’s: there is no AMI choice, no user data and no block device mappings, because AWS owns the image and the boot process. What you can set is the node IAM role, subnets, security groups and ephemeral storage, including a customer-managed KMS key:

YAML20 lines
# Custom NodeClass for EKS Auto Mode. Leave the built-in "default" NodeClass
# alone; create your own for private subnets, a custom node role or a
# customer-managed KMS key for node storage.
apiVersion: eks.amazonaws.com/v1
kind: NodeClass
metadata:
  name: private-encrypted
spec:
  role: AmazonEKSAutoNodeRole            # IAM role name; needs an EKS access entry
  subnetSelectorTerms:
    - tags:
        kubernetes.io/role/internal-elb: "1"
  securityGroupSelectorTerms:
    - tags:
        aws:eks:cluster-name: orders-prod
  ephemeralStorage:
    size: 80Gi
    iops: 3000
    throughput: 125
    kmsKeyID: alias/eks-node-storage

NodePools select instance attributes with eks.amazonaws.com/* labels, such as eks.amazonaws.com/instance-category and eks.amazonaws.com/instance-cpu, instead of Karpenter’s karpenter.k8s.aws/* labels. The sample has an on-demand general pool and a tainted Spot pool for batch work:

YAML65 lines
# General-purpose on-demand pool. Auto Mode uses eks.amazonaws.com/* labels
# for instance attributes, not karpenter.k8s.aws/*.
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: general-on-demand
spec:
  template:
    spec:
      nodeClassRef:
        group: eks.amazonaws.com
        kind: NodeClass
        name: private-encrypted
      expireAfter: 336h                  # 14 days; Auto Mode allows at most 21 days
      requirements:
        - key: karpenter.sh/capacity-type
          operator: In
          values: ["on-demand"]
        - key: kubernetes.io/arch
          operator: In
          values: ["amd64", "arm64"]
        - key: eks.amazonaws.com/instance-category
          operator: In
          values: ["c", "m", "r"]
        - key: eks.amazonaws.com/instance-cpu
          operator: In
          values: ["4", "8", "16"]
  disruption:
    consolidationPolicy: WhenEmptyOrUnderutilized
    consolidateAfter: 5m
    budgets:
      - nodes: "10%"
  limits:
    cpu: "400"
    memory: 1600Gi
---
# Spot pool for interruptible batch work. Pods must tolerate the taint.
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: batch-spot
spec:
  template:
    spec:
      nodeClassRef:
        group: eks.amazonaws.com
        kind: NodeClass
        name: private-encrypted
      expireAfter: 168h
      taints:
        - key: workload-type
          value: batch
          effect: NoSchedule
      requirements:
        - key: karpenter.sh/capacity-type
          operator: In
          values: ["spot"]
        - key: eks.amazonaws.com/instance-generation
          operator: Gt
          values: ["5"]
  disruption:
    consolidationPolicy: WhenEmptyOrUnderutilized
    consolidateAfter: 1m
  limits:
    cpu: "200"

expireAfter can shorten the node lifetime but not extend it past 21 days, and consolidation works as in Karpenter: WhenEmptyOrUnderutilized repacks pods onto fewer nodes, subject to the disruption budget.

Storage and load balancers

Auto Mode’s storage and load-balancing controllers are not the open-source ones, and they answer to different names. Auto Mode does not create a StorageClass; you create one on the ebs.csi.eks.amazonaws.com provisioner. Application Load Balancers come from an IngressClass whose controller is eks.amazonaws.com/alb, configured through an IngressClassParams resource rather than annotations on the IngressClass:

YAML17 lines
# Auto Mode does not create a StorageClass. Its block storage uses the
# ebs.csi.eks.amazonaws.com provisioner, not the self-managed ebs.csi.aws.com.
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: auto-ebs-gp3
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: ebs.csi.eks.amazonaws.com
volumeBindingMode: WaitForFirstConsumer
allowedTopologies:
  - matchLabelExpressions:
      - key: eks.amazonaws.com/compute-type
        values: ["auto"]
parameters:
  type: gp3
  encrypted: "true"
YAML19 lines
# Application Load Balancers in Auto Mode: IngressClassParams configures the
# load balancer; the IngressClass points at the eks.amazonaws.com/alb controller.
apiVersion: eks.amazonaws.com/v1
kind: IngressClassParams
metadata:
  name: internal-alb
spec:
  scheme: internal
---
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: internal-alb
spec:
  controller: eks.amazonaws.com/alb
  parameters:
    apiGroup: eks.amazonaws.com
    kind: IngressClassParams
    name: internal-alb
⚠️
VOLUMES DO NOT MOVE ON THEIR OWN

Persistent volumes created by the self-managed EBS CSI driver reference the ebs.csi.aws.com driver, while Auto Mode’s block storage uses ebs.csi.eks.amazonaws.com. Moving a stateful workload to Auto Mode nodes means migrating its data to a volume from the Auto Mode StorageClass, for example from a snapshot, or keeping that workload on a managed node group until you can. Plan this per StatefulSet before switching the cluster over.

Migrating an existing cluster

Auto Mode can be enabled on an existing cluster. AWS’s documented path from managed node groups is gradual: enable Auto Mode, add your NodePools, then delete the node groups one at a time with eksctl delete nodegroup, which drains their pods onto Auto Mode nodes. That guide assumes self-managed Karpenter is not installed; clusters running Karpenter have a separate migration guide. Most of the work is in the manifests. Karpenter resources, StorageClasses, IngressClasses and Ingress annotations written for the self-managed controllers need changes, and some settings have no Auto Mode equivalent.

%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#FFF3E0', 'primaryTextColor': '#232F3E', 'primaryBorderColor': '#FF9900', 'lineColor': '#232F3E', 'clusterBkg': '#F8FAFC', 'clusterBorder': '#CBD5E1', 'edgeLabelBackground': '#FFFFFF', 'nodeTextColor': '#232F3E'}}}%%
flowchart TD
    A["Lint manifests<br/>automode_lint.py"] --> B["Enable Auto Mode<br/>on the cluster"]
    B --> C["Apply your NodeClass,<br/>NodePools, StorageClass<br/>and IngressClass"]
    C --> D{"Stateful workloads<br/>on node group?"}
    D -- "Yes" --> E["Migrate volumes<br/>or keep on node group"]
    D -- "No" --> F["eksctl delete nodegroup<br/>one group at a time"]
    E --> F
    F --> G["Pods drain onto<br/>Auto Mode nodes"]
    G --> H{"Any node groups left?"}
    H -- "Yes" --> F
    H -- "No" --> I["Review self-managed add-ons<br/>that Auto Mode replaces"]
    classDef aws fill:#FFF3E0,stroke:#FF9900,stroke-width:2px,color:#232F3E
    classDef store fill:#F0FFF4,stroke:#1D8102,stroke-width:2px,color:#145202
    classDef warn fill:#FEF2F2,stroke:#D13212,stroke-width:2px,color:#991B1B
    class A,B,C,F,G,I aws
    class E warn
    class D,H store

The sample’s automode_lint.py reads a directory of manifests and reports those changes. Run against a typical cluster repository that used Karpenter and the self-managed load balancer controller, it reports:

Bash11 lines
$ python automode_lint.py orders-k8s
ERROR   orders-k8s/cluster.yaml EC2NodeClass/default: Karpenter EC2NodeClass is not used by Auto Mode; create an eks.amazonaws.com/v1 NodeClass
ERROR   orders-k8s/cluster.yaml NodePool/general: nodeClassRef must be group eks.amazonaws.com, kind NodeClass
ERROR   orders-k8s/cluster.yaml NodePool/general: requirement karpenter.k8s.aws/instance-category is not used by Auto Mode; use eks.amazonaws.com/instance-category
ERROR   orders-k8s/cluster.yaml NodePool/general: requirement kubernetes.io/os is not supported; Auto Mode runs Linux nodes only
ERROR   orders-k8s/cluster.yaml NodePool/general: expireAfter 720h exceeds Auto Mode's 21-day (504h) maximum node lifetime
WARNING orders-k8s/cluster.yaml StorageClass/gp3: provisioner ebs.csi.aws.com is the self-managed EBS CSI driver; Auto Mode volumes use ebs.csi.eks.amazonaws.com
ERROR   orders-k8s/cluster.yaml Ingress/web: kubernetes.io/ingress.class is not supported; set spec.ingressClassName
ERROR   orders-k8s/cluster.yaml Ingress/web: alb.ingress.kubernetes.io/group.name is not supported; define groups in IngressClassParams
WARNING orders-k8s/cluster.yaml Deployment/api: nodeSelector eks.amazonaws.com/nodegroup pins pods to a managed node group; select on NodePool labels instead
7 error(s), 2 warning(s)

The checks are plain Python over the parsed YAML, so they are easy to extend with your own rules. This is the core of it:

Python174 lines
"""Lint Kubernetes manifests for a move to Amazon EKS Auto Mode.

Teams moving from managed node groups or self-managed Karpenter usually carry
manifests that Auto Mode handles differently. This script reads YAML files and
reports what has to change:

- Karpenter EC2NodeClass objects (Auto Mode uses eks.amazonaws.com/v1 NodeClass)
  and NodeClass fields Auto Mode does not offer (custom AMIs, user data, block
  device mappings).
- NodePools that reference the wrong node class, use karpenter.k8s.aws/*
  instance labels, request Windows, or set expireAfter above Auto Mode's
  21-day maximum node lifetime.
- StorageClasses on the self-managed EBS CSI provisioner, Ingresses using the
  deprecated class annotation, and workloads pinned to managed node groups.

It reads files only and needs no cluster access.
Exit code: 0 when there are no errors, 1 when there are, 2 on usage errors.
"""

from __future__ import annotations

import argparse
import re
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Iterator

import yaml

MAX_NODE_LIFETIME_HOURS = 21 * 24
UNSUPPORTED_NODECLASS_FIELDS = {
    "amiFamily": "Auto Mode nodes run an AWS-managed Bottlerocket-based AMI",
    "amiSelectorTerms": "custom AMIs are not supported",
    "userData": "user data is not supported; nodes cannot be customised at boot",
    "blockDeviceMappings": "use spec.ephemeralStorage (size, iops, throughput, kmsKeyID)",
    "metadataOptions": "instance metadata settings are managed by Auto Mode",
    "instanceStorePolicy": "not available in Auto Mode",
}
SUPPORTED_KARPENTER_AWS_LABELS = {"karpenter.k8s.aws/instance-tenancy"}
WORKLOAD_KINDS = {"Deployment", "StatefulSet", "DaemonSet", "Job", "ReplicaSet"}


@dataclass
class Finding:
    level: str  # ERROR or WARNING
    file: str
    obj: str
    message: str

    def __str__(self) -> str:
        return f"{self.level:<7} {self.file} {self.obj}: {self.message}"


def parse_hours(value: str) -> float | None:
    """Parse a Go duration such as '336h', '720h30m' or '90m' into hours. 'Never' -> inf."""
    if value == "Never":
        return float("inf")
    parts = re.fullmatch(r"(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?", value or "")
    if not parts or not any(parts.groups()):
        return None
    h, m, s = (int(p) if p else 0 for p in parts.groups())
    return h + m / 60 + s / 3600


def _documents(path: Path) -> Iterator[dict[str, Any]]:
    for doc in yaml.safe_load_all(path.read_text(encoding="utf-8")):
        if isinstance(doc, dict) and doc.get("kind"):
            yield doc


def _pod_spec(doc: dict[str, Any]) -> dict[str, Any]:
    spec = doc.get("spec") or {}
    if doc["kind"] == "Pod":
        return spec
    template = spec.get("jobTemplate", {}).get("spec", spec) if doc["kind"] == "CronJob" else spec
    return (template.get("template") or {}).get("spec") or {}


def lint_document(doc: dict[str, Any], file: str) -> list[Finding]:
    kind, api = doc.get("kind"), doc.get("apiVersion", "")
    name = f"{kind}/{(doc.get('metadata') or {}).get('name', '?')}"
    spec = doc.get("spec") or {}
    out: list[Finding] = []

    def add(level: str, msg: str) -> None:
        out.append(Finding(level, file, name, msg))

    if kind == "EC2NodeClass" or api.startswith("karpenter.k8s.aws/"):
        add("ERROR", "Karpenter EC2NodeClass is not used by Auto Mode; create an eks.amazonaws.com/v1 NodeClass")

    if kind == "NodeClass" and api.startswith("eks.amazonaws.com/"):
        for field_name, why in UNSUPPORTED_NODECLASS_FIELDS.items():
            if field_name in spec:
                add("ERROR", f"spec.{field_name} is not supported: {why}")
        if "role" in spec and "instanceProfile" in spec:
            add("ERROR", "spec.role and spec.instanceProfile are mutually exclusive")
        for required in ("subnetSelectorTerms", "securityGroupSelectorTerms"):
            if not spec.get(required):
                add("ERROR", f"spec.{required} is required")

    if kind == "NodePool":
        template = (spec.get("template") or {}).get("spec") or {}
        ref = template.get("nodeClassRef") or {}
        if (ref.get("group"), ref.get("kind")) != ("eks.amazonaws.com", "NodeClass"):
            add("ERROR", "nodeClassRef must be group eks.amazonaws.com, kind NodeClass")
        if ref.get("name") == "default" and (doc.get("metadata") or {}).get("name") in {"system", "general-purpose"}:
            add("WARNING", "this looks like a built-in NodePool; do not edit built-in pools, create your own")
        for req in template.get("requirements") or []:
            key = req.get("key", "")
            if key.startswith("karpenter.k8s.aws/") and key not in SUPPORTED_KARPENTER_AWS_LABELS:
                add("ERROR", f"requirement {key} is not used by Auto Mode; use eks.amazonaws.com/{key.split('/', 1)[1]}")
            if key in {"kubernetes.io/os", "node.kubernetes.io/windows-build"}:
                add("ERROR", f"requirement {key} is not supported; Auto Mode runs Linux nodes only")
        expire = template.get("expireAfter")
        if expire is not None:
            hours = parse_hours(str(expire))
            if hours is None:
                add("ERROR", f"expireAfter {expire!r} is not a valid duration")
            elif hours > MAX_NODE_LIFETIME_HOURS:
                add("ERROR", f"expireAfter {expire} exceeds Auto Mode's 21-day (504h) maximum node lifetime")

    if kind == "StorageClass" and doc.get("provisioner") == "ebs.csi.aws.com":
        add("WARNING", "provisioner ebs.csi.aws.com is the self-managed EBS CSI driver; Auto Mode volumes use ebs.csi.eks.amazonaws.com")

    if kind == "IngressClass" and spec.get("controller") == "ingress.k8s.aws/alb":
        add("WARNING", "controller ingress.k8s.aws/alb is the self-managed Load Balancer Controller; Auto Mode uses eks.amazonaws.com/alb")
    if kind == "IngressClassParams" and api.startswith("elbv2.k8s.aws/"):
        add("WARNING", "IngressClassParams moves from elbv2.k8s.aws/v1beta1 to eks.amazonaws.com/v1, with renamed fields")
    if kind == "Ingress":
        annotations = (doc.get("metadata") or {}).get("annotations") or {}
        if "kubernetes.io/ingress.class" in annotations:
            add("ERROR", "kubernetes.io/ingress.class is not supported; set spec.ingressClassName")
        if "alb.ingress.kubernetes.io/group.name" in annotations:
            add("ERROR", "alb.ingress.kubernetes.io/group.name is not supported; define groups in IngressClassParams")

    if kind in WORKLOAD_KINDS | {"Pod", "CronJob"}:
        selector = _pod_spec(doc).get("nodeSelector") or {}
        for key in selector:
            if key.startswith("eks.amazonaws.com/nodegroup"):
                add("WARNING", f"nodeSelector {key} pins pods to a managed node group; select on NodePool labels instead")
    return out


def lint_paths(paths: list[Path]) -> list[Finding]:
    findings: list[Finding] = []
    for path in paths:
        files = sorted(path.rglob("*.y*ml")) if path.is_dir() else [path]
        for f in files:
            try:
                for doc in _documents(f):
                    findings.extend(lint_document(doc, str(f)))
            except yaml.YAMLError as exc:
                findings.append(Finding("ERROR", str(f), "-", f"invalid YAML: {exc}"))
    return findings


def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    parser.add_argument("paths", nargs="+", type=Path)
    args = parser.parse_args(argv)
    missing = [p for p in args.paths if not p.exists()]
    if missing:
        parser.error(f"not found: {', '.join(map(str, missing))}")
    findings = lint_paths(args.paths)
    for f in findings:
        print(f)
    errors = sum(f.level == "ERROR" for f in findings)
    print(f"{errors} error(s), {len(findings) - errors} warning(s)")
    return 1 if errors else 0


if __name__ == "__main__":
    sys.exit(main())

Cost

Auto Mode adds a management charge per instance it launches, on top of the EC2 price. It is billed per second with a one-minute minimum, varies by instance type, and does not change with the purchase option: Savings Plans, Reserved Instances and Spot reduce the EC2 part, not the Auto Mode part. In AWS’s published examples the charge is about 12% of the On-Demand EC2 price.

AWS example, US West (Oregon)EC2 per hourAuto Mode per hour
c6a.2xlarge$0.306$0.03672
c6a.4xlarge$0.612$0.07344
m5a.2xlarge$0.344$0.04128
m5a.xlarge$0.172$0.02064
Total for one of each, per month$1,046.82$125.62

Worked cell: $0.306 × 12% = $0.03672 for the c6a.2xlarge. On Spot or with a Savings Plan the EC2 column falls and the Auto Mode column does not, so the charge becomes a larger share of the bill. Weigh it against what the team spends today on node AMI updates, add-on upgrades and Karpenter operations; for a small platform team that is usually the larger number, and for a large one running a well-tuned Karpenter it may not be.

Production considerations

  • Set PodDisruptionBudgets. Nodes are replaced at least every 21 days and on every AMI release; budgets and multiple replicas keep that invisible. A PDB that allows no disruption blocks updates and needs attention before the lifetime limit.
  • Use your own NodeClass. Put nodes in private subnets, set the node role you want, and encrypt ephemeral storage with your KMS key; leave the built-in pools as they are.
  • Size requests honestly. Karpenter picks instances from pod requests, so inflated requests buy bigger nodes and under-stated ones cause evictions.
  • Keep exceptions on node groups. Windows nodes, custom AMIs, kernel modules and agents that need host access can stay on a managed node group in the same cluster.
  • Watch the bill by NodePool. Label NodePools by team or workload and use cost allocation tags so the Auto Mode charge is attributable.
⚖️
NODE ACCESS AND AUDIT

Because SSH and SSM are blocked and the AMI is AWS-managed, host-level agents that some security standards expect, such as file integrity monitoring or endpoint protection installed on the node, cannot be installed the usual way. Check whether your controls can be met with DaemonSets, AWS security services and node logs before moving regulated workloads, and record the shared-responsibility change in your security documentation.

Decision framework

Matrix comparing EKS Auto Mode, managed node groups, self-managed Karpenter and Fargate on node scaling, OS patching, core add-ons, node customisation, extra charge and operating system
Auto Mode is the low-effort EC2 option. Node groups and your own Karpenter keep control of the AMI and avoid the per-instance charge.

Use Auto Mode for new clusters and for teams whose job is shipping applications, not running node fleets: Linux workloads, standard networking, and no need for custom AMIs or host agents. Keep managed node groups or your own Karpenter where you need Windows, custom AMIs, kernel tuning beyond what the NodeClass offers, or where a large, steady fleet makes the per-instance charge outweigh the operational saving. Mix them in one cluster when most workloads fit Auto Mode and a few do not.

The choice changes with scale and staffing: the per-instance charge grows with the fleet, while the work it replaces grows more slowly. Recalculate when the cluster doubles or the platform team changes size.

📝
HOW THIS WAS CHECKED

automode_lint.py was tested with Python 3.13, pyyaml==6.0.3 and pytest==9.0.2: twelve tests cover each rule, duration parsing, exit codes, and a check that the sample manifests lint clean. The manifests use the field names from the EKS Auto Mode user guide but were not applied to a cluster for this article. Prices are AWS’s published example from the EKS pricing page.

Key takeaways

  • EKS Auto Mode has been generally available since 1 December 2024 for clusters on Kubernetes 1.29 or later.
  • AWS runs node provisioning (Karpenter-based), networking, EBS storage, load balancing and DNS, and manages nodes on a Bottlerocket-based AMI with no SSH or SSM and a 21-day maximum lifetime.
  • You shape nodes with Karpenter NodePools and an Auto Mode NodeClass (eks.amazonaws.com/v1), using eks.amazonaws.com/* instance labels.
  • Storage and load balancers use Auto Mode’s own controllers, so StorageClasses, IngressClasses and some Ingress annotations must change, and existing volumes need migrating.
  • The per-instance charge, about 12% of On-Demand in AWS’s examples, is not reduced by Savings Plans or Spot.

Have you moved a cluster to Auto Mode, and which workloads did you keep on node groups? Share it in the comments.

Glossary

EKS Auto Mode
An EKS feature in which AWS provisions, patches and scales worker nodes and runs core cluster add-ons.
NodePool
A Karpenter resource that defines which instances can be launched, limits and disruption rules.
NodeClass
The Auto Mode resource for AWS-specific node settings: role, subnets, security groups and storage.
EC2NodeClass
The self-managed Karpenter equivalent of NodeClass, not used by Auto Mode.
Consolidation
Karpenter replacing or removing nodes so pods fit on fewer or cheaper instances.
Bottlerocket
An AWS Linux-based operating system built for running containers.
PodDisruptionBudget
A Kubernetes object that limits how many pods of an application can be evicted at once.
IngressClassParams
The Auto Mode resource that configures Application Load Balancers for an IngressClass.

References & Further Reading


Discover more from C4: Container, Code, Cloud & Context

Subscribe to get the latest posts sent to your email.

Written by

Nithin Mohan TK

Hello Namaste! 👋🏻 I'm an accomplished Enterprise Solution Architect & Engineering Leader with 20+ years of progressive experience architecting, building, and scaling transformative enterprise solutions. ⚜️ Solution Architect / AI & Cloud 📌 Galway, Ireland

Leave a comment

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.