In May 2026, Amazon Web Services popped a cork over AWS Transform. Now, using agentic AI, organisations can automate a lot of the grind involved in converting existing applications into containers in the cloud migration process.
For anyone who’s spent time wrestling with creaking applications, this was a welcome development. But just because an application can be containerised more easily, does that mean it's ready to be modernised?
Containerisation basically gives an application a more portable and consistent environment in which to run. Which is tremendously useful. Particularly when deploying software across different environments. But, like a gap-year student arriving at an Indian ashram, the application inside that container still brings its existing peculiarities along for the ride.
So, before embarking on an AWS container modernisation project, here are five decisions you absolutely need to get right.
1. Decide what you're actually trying to improve
There's always a temptation in technology to start with the solution, especially when it’s shiny and new.
The business has an ageing application and containers promise greater flexibility. Kubernetes sounds like a plan, and before long, you’re discussing migration timelines. But what problem are you actually trying to solve?
Is it software releases that’ve become painfully complicated? Maybe maintaining the underlying infrastructure is consuming too much engineering time, or the application is struggling to accommodate the boom of a hot new product launch. Each of these problems calls for a different approach.
AWS identifies several migration and modernisation strategies. Re-hosting is a light touch approach. Re-platforming offers targeted improvements. Refactoring goes even further by tailoring the underlying application architecture.
But while a complete redesign might offer substantial benefits, it could also rear everyone’s least favourite twins: cost and risk. Sometimes, simply moving an application into a better operating environment is the only improvement the business needs.
Kinetic truth bomb: Forget fashionable solutions. A shiny new architecture won't fix a problem you haven't properly diagnosed. Modernise with a business objective in mind.
2. Understand exactly what it is that you're putting inside the container
Here's where container modernisation can become far more entertaining than anyone either wanted or even thought possible. Buckle up!
Imagine an application that's been running reliably since you launched. Its components share a database and important processes depend on files written directly to the server. Par for the course.
Now imagine putting it into containers and running several instances simultaneously. What happens when a user's session is tied to a container that suddenly disappears? Where does another instance find the files it needs? Can a container shut down gracefully without interrupting a transaction?
These are the sorts of questions that turn a straightforward migration into architectural archaeology.
Examining application dependencies and runtime requirements before containerisation is a no-brainer because portability doesn't guarantee that an application will behave as expected in a distributed environment.
One option is incremental modernisation using the strangler fig pattern – a wonderfully descriptive name borrowed from nature. Rather than replacing an entire application in one fell swoop, new components are introduced gradually. And over time, they assume more and more of its responsibilities.
And here's something worth remembering: containerisation doesn't mean every application needs to become a sprawling collection of micro-services. A well-designed monolith can run perfectly happily in containers.
Skunk tip: Before containerising, map dependencies. Anything relying on local storage or shared sessions or external services needs to be flagged. Because the surprises almost always come from what nobody thought to document.
3. Choose an AWS platform your team can operate
AWS offers a cornucopia of containers. Choose wisely. Give it more thought than: “Well this technology clearly has the most impressive capabilities.”
Amazon Elastic Container Service (ECS) provides AWS-native container orchestration and is often a sensible choice for organisations looking to minimise operational complexity.
Amazon Elastic Kubernetes Service (EKS) provides managed Kubernetes capabilities, making it attractive to teams that need Kubernetes APIs or already have established Kubernetes expertise.
Then there's AWS Fargate, which allows compatible ECS and EKS workloads to run without managing the underlying servers.
EKS Auto Mode takes AWS-managed infrastructure even further; it automates additional responsibilities associated with operating Kubernetes clusters.
But while there's a great deal to appreciate in these services, a company with a relatively straightforward application and limited Kubernetes experience might find itself maintaining a level of complexity that doesn’t justify a return on effort in terms of actual additional business value.
Kinetic truth bomb: Kubernetes isn't a badge of engineering sophistication. If your team spends more time managing the platform than improving the application, you've probably introduced the wrong kind of complexity.
4. Build security and release discipline into the process
Containers are remarkably good at making application deployments more consistent. But security cannot, under any circumstances, be a casualty in the process.
A container image can contain vulnerable libraries or insecure configurations. Packaging those components neatly doesn't make their vulnerabilities disappear.
Amazon Elastic Container Registry (ECR) supports container image scanning, helping teams identify known software vulnerabilities. AWS Identity and Access Management (IAM) provides mechanisms for controlling what applications and workloads can access.
But scanning an image is not enough. If a developer releases a new version, it still needs to be tested against the existing application, and dependencies need to be carefully examined. And then what if something goes wrong? Can the previous version be restored? Really? Can you prove it?
Automated delivery pipelines with security checks and quality testing are enticing, but someone still needs to verify the outcome.
Skunk tip: Treat every container image as a new software release. Scan its dependencies and test its behaviour. Automation should make quality controls easier to enforce, not easier to skip.
5. Prove the new environment works before declaring success
There's a satisfying moment in every migration project when the application starts running in its new environment. Everyone can finally see the result of their efforts. It's tempting to declare victory. But what have we actually proved?
An application running in ECS or EKS doesn't always mean it's faster or more resilient. It might still struggle with the demands of production. Which is where quality engineering becomes particularly important.
Performance testing should examine how the application behaves under realistic conditions, including its interactions with databases and connected services. Observability needs to reveal where problems originate, rather than simply reporting that something has gone wrong. And recovery procedures also deserve attention, not to mention the question of ownership. AWS might manage more of the underlying infrastructure, but somebody still needs to operate the application and respond when things go wrong.
Before the modernisation project is considered complete, the business should have a clear understanding of the platform's performance, operating costs and ongoing support responsibilities.
Kinetic truth bomb: Getting an application into a container is a deployment milestone. Proving that it performs better, costs what you expected and can recover when things go wrong? That's modernisation.
Frequently asked questions about AWS container modernisation
What is the difference between containerisation and application modernisation?
Containerisation packages an application and its dependencies into a consistent runtime environment. Application modernisation changes the application, its architecture or how it is operated to achieve a business goal, such as simpler releases or better performance. Containerisation can support modernisation, but the application still needs to be assessed, tested and operated effectively. Moving it into a container does not automatically resolve existing design problems.
What should you assess before containerising an application on AWS?
Before containerising an application on AWS, define the business outcome and map the application’s dependencies and runtime requirements. Check databases, external services, local file storage, session handling and shutdown behaviour. Establish baseline performance and operating costs so the team can measure improvement. These findings help determine whether the application needs limited changes or a more substantial redesign.
Does container modernisation require micro-services?
No. A monolithic application can run in containers without being divided into micro-services. The decision to separate components should follow a clear need, such as independent releases or different scaling requirements. Where separation is justified, incremental modernisation can introduce new components gradually. It also creates additional dependencies and operational responsibilities that the team needs to manage.
How should you choose between Amazon ECS, Amazon EKS and AWS Fargate?
Choose Amazon Elastic Container Service (Amazon ECS) when AWS-native orchestration fits the application and operating model. Choose Amazon Elastic Kubernetes Service (Amazon EKS) when Kubernetes APIs, tooling or established team expertise justify it. AWS Fargate is a compute option for compatible ECS and EKS workloads, rather than a separate orchestration platform. It removes the need to manage the underlying servers. Assess workload compatibility, team capacity, operational effort and total cost before deciding.
Is container image scanning enough to secure an application release?
No. Container image scanning identifies known software vulnerabilities within its scanning scope; it does not establish that an application release is secure or behaves correctly. Amazon Elastic Container Registry (Amazon ECR) supports image scanning, but teams must also review access permissions and configuration, test application behaviour and dependencies, and validate rollback procedures. Release controls need clear owners who assess findings and decide whether a release can proceed.
What should you validate before declaring AWS container modernisation complete?
Validate the modernised application against agreed business and operational targets before declaring the project complete. Test realistic workloads and database interactions, confirm that observability helps locate faults and rehearse recovery and rollback procedures. Compare operating costs and performance with the original baseline. Assign responsibility for releases, incident response and ongoing support. A successful deployment shows that the application starts; operational validation shows whether it is ready to serve customers.
Editorial references and review
The questions are drawn from the article’s buyer decisions, not measured search-volume data. Answers open directly, name the relevant entities and stand alone. Keep them as accessible text. This supports interpretation and discovery; it does not guarantee AI citations or search visibility. Technical references checked 15 November 2026; review platform details before publication and again by 15 February 2027.
AWS – Choosing an AWS container service (platform choice)
AWS – Fargate with Amazon EKS (compatibility and responsibilities)
AWS – Amazon ECR image scanning (scanning scope)
Google Search Central – AI features and your website (publishing guidance)
Modernisation is a continuing engineering responsibility
AWS is making container modernisation increasingly accessible, and agentic AI promises to remove a substantial amount of repetitive engineering work. But as the tools become more sophisticated, the quality of the decisions surrounding them becomes even more important.
KineticSkunk sees cloud modernisation as part of a broader cloud platform engineering discipline. Its engineers help organisations assess existing environments, modernise applications and establish the operational practices needed to support them on AWS.
Through KineticSkunk's Cloud Managed Platform Solutions and Platform Assurance capabilities, the company connects architectural improvements with software quality and ongoing responsibility for the environment.
Because the best modernisation projects don't just give old applications a new lease on life. They give businesses the confidence to imagine what those applications could become.
Editorial contacts

