Introduction

20× faster. That’s what customers are seeing when AI-powered automation replaces the manual containerization work that used to consume days of senior engineer time per application.

“AWS Transform took our applications from source code to running containers on EKS in just 4-8 hours per app. What used to take 8-10 days is now 20 times faster. The automation generated Dockerfiles and Helm charts, giving us the confidence to scale containerization across our entire portfolio.” – Malte Sobe, Lead Cloud Migration, Kuehne+Nagel

With approximately 88,000 employees across more than 1,300 sites in nearly 100 countries, the Kuehne+Nagel Group, one of the world’s leading logistics providers, needed to containerize 10 on-premises Red Hat Enterprise Linux (RHEL) applications onto Amazon Elastic Kubernetes Service (Amazon EKS) as part of a multi-year cloud migration. A simple lift-and-shift wouldn’t deliver the operational agility and cost efficiency these workloads demanded. But the manual approach to containerization (tracing dependencies, authoring Dockerfiles, generating Helm charts) consumed over a week per application. That pace couldn’t keep up with the migration timeline. The Kuehne+Nagel migration team first applied AWS Transform’s source code containerization capability to 4 representative RHEL applications, then scaled it across all 10 applications in scope. Each was delivered with a complete, production-ready artifact set: a validated Dockerfile, parameterized Helm charts, and Kubernetes manifests, in hours, not days. With enterprises increasingly under pressure to modernize during migration rather than after, this program demonstrates a repeatable pattern now available to any organization running containerization at scale on AWS.

The challenge

As enterprises accelerate cloud migration timelines, containerization has emerged as the dominant replatforming strategy, but manual effort remains the primary bottleneck. When Kuehne+Nagel committed to a three-year cloud migration to AWS, the scope reflected the scale of a global logistics leader managing supply chains for thousands of customers: hundreds of applications with a strategy to modernize where the business case supports it. Within that portfolio, 10 RHEL-based applications were identified as candidates for the “Move to Containers” pattern, targeting Amazon EKS. These were complex enterprise workloads with dependencies on external libraries, specific runtime configurations, multi-repository codebases, and years of accumulated build complexity.

What manual containerization requires

A thorough manual containerization engagement requires an engineer to:

1. Analyze the application’s source code end to end
2. Map all library and framework dependencies
3. Understand the build system and external artifact requirements
4. Characterize the runtime environment
5. Select an appropriate base container image
6. Author a production-ready Dockerfile
7. Validate the container builds and runs correctly
8. Generate deployment artifacts (Helm charts, Kubernetes manifests, configuration)

Working through this process for an enterprise application averages 8-10 days of senior engineer time. Until now, containerizing 10 enterprise applications within an active migration timeline was simply not feasible at this pace. AWS Transform’s source code containerization made it possible, bringing containerization into the migration workflow itself, rather than treating it as a separate, sequential effort.

The solution: AWS Transform source code containerization

The Kuehne+Nagel migration team evaluated approaches to accelerate containerization and selected AWS Transform’s source code containerization capability. AWS Transform is an agentic AI service developed to accelerate enterprise transformations. Rather than relying on a generic large language model, its containerization agent uses curated skills and templates that encode AWS-recommended best practices gathered over years of managing containers at scale. The service enabled Kuehne+Nagel to migrate and modernize in parallel, replatforming applications to containers within the same workflow used for their broader migration program, rather than choosing between speed and modernization. The team connected their GitLab repositories, configured their private dependency sources, and the agent handled the rest through a chat-based, goal-driven workflow.

AWS Transform source code containerization supports replatforming applications to containers during migration to AWS, with source code from GitHub, Bitbucket, GitLab, or .zip files. For full details, see the source code containerization documentation.

Key capabilities

• AI-driven source code analysis: analyzes application source code and automatically generates Docker artifacts (Dockerfiles, configuration files) without requiring Docker expertise
• Container image building and publishing: builds and tests container images automatically, publishes to Amazon ECR with automated vulnerability scanning
• Infrastructure as Code generation: generates production-ready Helm charts (for Amazon EKS) or Terraform modules (for Amazon ECS) with automated validation and security scanning
• Private dependency support: supports AWS CodeArtifact repositories (Maven, PyPI, npm) and private Amazon ECR base images as dependency sources
• Iterative test and cutover deployment: deploys test infrastructure for validation, then deploys finalized infrastructure for production cutover
• Flexible source code input: source code can be provided from Git repositories via AWS CodeConnections (supporting GitHub, Bitbucket, and GitLab) or uploaded as zip files. Supports .NET 7+, Java, Python, Node.js, Go, and other general-purpose application frameworks.

Human-in-the-loop governance

AWS Transform uses a chat-based workflow where an AI-powered agent guides the team through each containerization step. At key points in the workflow, engineers review and approve the output before proceeding. Every artifact the service generates (Dockerfiles, Helm charts, Kubernetes manifest files) is validated by a migration engineer before being applied. This deliberate design choice helps maintain consistent quality, keeps engineers accountable, and builds confidence among security and compliance teams.

How it works at Kuehne+Nagel: The six-step workflow

Figure 1: High-Level Solution Overview: RHEL applications flow through AWS Transform to produce production-ready artifacts deployed on Amazon EKS.

Figure 2: Detailed Six-Step Workflow. Steps 1-4 are fully automated by AWS Transform. Step 5 (Human-in-the-Loop Review) provides enterprise governance. Step 6 shows the three deployment tracks: Terraform for EKS infrastructure, GitLab CI for Docker image build, and ArgoCD for GitOps deployment.

Steps 1-4: Automated analysis, generation, and validation

Once the migration team connected their GitLab repositories and configured private dependency sources (internal CodeArtifact repositories and package registries), AWS Transform handled the heavy lifting:

1. Source code and runtime analysis. The agent connected to each repository, traced execution paths, mapped frameworks and library dependencies, and characterized the runtime environment. What previously took days of manual dependency tracing completed in minutes.
2. Dockerfile generation. From the analysis, AWS Transform generated a purpose-built Dockerfile for each application, selecting the appropriate base image, constructing multi-stage build sequences, and resolving dependencies from Kuehne+Nagel’s external artifact repositories. These were not generic templates; each Dockerfile reflected the specific dependency tree and runtime configuration of its application.
3. Dockerfile validation. AWS Transform automatically built the container image, confirmed all dependencies resolved, and verified the containerized application started correctly. The agent also performed automated security scans, flagging hardcoded credentials, identifying Common Vulnerabilities and Exposures (CVEs), and ensuring the image was production-safe. If a build failed, the agent iterated on the Dockerfile without manual intervention, eliminating the back-and-forth that typically consumes hours of engineer time.
4. Helm chart and deployment artifact generation. AWS Transform generated parameterized Helm charts and Kubernetes manifests targeting Kuehne+Nagel’s Amazon EKS environment across development, staging, and production. It also generated deployment documentation covering how to build, run, and configure the containerized application. The generated Helm charts integrated into KN’s existing pipelines with limited configuration.

Step 5: Human-in-the-Loop Review

Kuehne+Nagel’s migration team had invested upfront effort in defining production-readiness criteria, establishing security review baselines, and gaining organizational buy-in from compliance teams to evaluate AI-generated artifacts. With this governance framework in place, migration engineers reviewed each artifact set, confirming application behavior, verifying security and compliance requirements, and authorizing promotion to production. The automation elevated engineers to focus on judgment-intensive decisions rather than repetitive manual authoring.

Step 6: Integration into Kuehne+Nagel’s Deployment Ecosystem

Kuehne+Nagel operates a mature GitOps-based deployment pipeline built on Terraform, GitLab CI, and ArgoCD. AWS Transform’s output (Dockerfiles, Helm charts, and Kubernetes manifests) was designed to slot directly into this existing ecosystem:

• Terraform provisions the EKS infrastructure
• GitLab CI builds and pushes container images
• ArgoCD handles GitOps-based deployment to the cluster

No new tooling was required. The generated artifacts integrated into existing pipelines with limited configuration changes and no governance model changes.

Results

Containerization of all 10 applications delivered conclusive results across speed, quality, and scalability:

• 4-8 hours per application (down from 8-10 days), up to 20× faster. Without that acceleration, containerizing 10 applications within an active migration timeline would have required either doubling the team or extending the program by months. Neither was acceptable.
• Complete, production-ready artifact sets for each application (Dockerfile + Helm charts + Kubernetes manifests)
• Consistent, enterprise-grade quality across different application types

Before and after comparison

From per-app acceleration to program-level impact

The per-application speed improvement is significant on its own, but the real value shows up at the program level. By compressing containerization from days of sequential engineering work into hours of automated pipeline execution, Kuehne+Nagel was able to run containerization within their active migration timeline rather than blocking it, and once the first wave validated the approach, the team completed the remaining applications without extending the program timeline.

What made this work

Human-in-the-loop governance is non-negotiable. Enterprise organizations operate under significant security and compliance requirements. Keeping a qualified engineer in the review role for every artifact set was a prerequisite for earning trust from security teams. The automation accelerated the work; the human governance made it acceptable to the organization.

The compounding improvement effect is real. Observations from each review cycle were captured and fed back into the workflow. Each review cycle generated feedback that informed subsequent runs, contributing to a progressively smoother workflow for later applications compared to those processed in the first wave. Organizations should treat the feedback mechanism as a first-class engineering asset.

Production-ready outputs reduced downstream rework. AWS Transform produced deployable artifacts, not partial templates, giving the team a strong starting point. The Helm charts and Dockerfiles fit into the existing GitLab CI and ArgoCD pipelines with limited configuration.

Conclusion

Containerization has traditionally forced enterprises into a tradeoff: invest weeks of senior engineering time per application, or skip modernization and lift-and-shift to VMs. Kuehne+Nagel refused that tradeoff. By applying AWS Transform’s source code containerization to their RHEL portfolio, they compressed per-application effort from 8-10 days to 4-8 hours, kept their migration program on schedule and delivered production-ready artifacts that integrated directly into their existing GitOps pipeline. The governance model (human-in-the-loop review at every stage) gave security and compliance teams the confidence to approve AI-generated infrastructure artifacts at scale. What matters most: this isn’t a proof-of-concept. Kuehne+Nagel validated the approach on 4 complex enterprise applications and then completed containerization across all 10 applications in scope. The pattern is repeatable, the artifacts are production-grade, and the economics fundamentally change what’s feasible within a migration timeline.

Ready to accelerate your containerization journey?

• Learn more about AWS Transform: aws.amazon.com/transform
• Explore the Source code containerization user guide
• Read more about this Containerize during migration: Replatform applications to containers with AWS Transform
• Contact your AWS account team to scope a first-wave pilot

About Kuehne+Nagel

With approximately 88,000 employees across over 1,300 sites in close to 100 countries, the Kuehne+Nagel Group is one of the world’s leading logistics providers. Headquartered in Switzerland and listed on the Zurich stock exchange, it is the global number one in Air and Sea Logistics and holds strong market positions in Road and Contract Logistics. Supporting around 400,000 customers worldwide, the Group draws on its global network, logistics expertise, and data-driven insights to deliver end-to-end supply chain solutions for global companies and industries.

About the authors